Metacat

/**

 *  '$RCSfile$'

 *    Purpose: a single workflow job that is schedulable 

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

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Michael Daigle

 *

 *   '$Author: daigle $'

 *     '$Date: 2008-07-06 21:25:34 -0700 (Sun, 06 Jul 2008) $'

 * '$Revision: 4080 $'

 *

 * 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.rmi.RemoteException;

import javax.xml.rpc.ServiceException;

import org.apache.log4j.Logger;

import org.quartz.InterruptableJob;

import org.quartz.JobDetail;

import org.quartz.JobDataMap;

import org.quartz.JobExecutionContext;

import org.quartz.JobExecutionException;

import org.kepler.executionWS.KeplerWebServiceLocator;

import org.kepler.executionWS.KeplerWebServicePortType;

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

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

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

public class WorkflowJob implements InterruptableJob {

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

	/**

	 * Required method that is called when the job is run by the scheduler.

	 * 

	 * @param executionContext

	 *            the context information for this job

	 */

	public void execute(JobExecutionContext executionContext) throws JobExecutionException {

		try {

			// have to be able to get the job detail

			JobDetail jobDetail = executionContext.getJobDetail();

			if (jobDetail == null) {

				throw new JobExecutionException("WorkflowJob.execute - Could not get job detail from execution context"); 

			}

			// have to be able to get the job data map from the job detail

			JobDataMap jobDataMap = jobDetail.getJobDataMap();

			if (jobDataMap == null) {

				throw new JobExecutionException("WorkflowJob.execute - Could not get job data map from job detail"); 

			}

			String jobName = jobDetail.getName();

			ScheduledJobAccess jobAccess = new ScheduledJobAccess();

			ScheduledJobDAO jobDAO = jobAccess.getJobByName(jobName);

			if(jobDAO == null) {

				String errorMessage = "WorkflowJob.execute - Could not retrieve job info from " 

					+ "database for job: " + jobName;

				logMetacat.error(errorMessage);

				throw new JobExecutionException(errorMessage);

			}

			// the kar lsid must be part of the job data map

			ScheduledJobParamDAO jobParamDAO = jobDAO.getAllJobParams().get("karid");

			if (jobParamDAO == null) {

				throw new JobExecutionException("WorkflowJob.execute - Could not get job param named karid from " 

						+ "job data map for job: " + jobName);

			}

			String karLSID = jobParamDAO.getValue();

			if (karLSID == null) {

				throw new JobExecutionException("WorkflowJob.execute - Could not get kar LSID for job: " + jobName);

			}

			// Locate service

			logMetacat.debug("WorkflowJob.execute - Getting kepler webservice Locator");

			KeplerWebServiceLocator serviceLocator = new KeplerWebServiceLocator();

			// get endpoint service

			logMetacat.debug("WorkflowJob.execute - Getting kepler webservice");

			KeplerWebServicePortType serviceEndpoint = serviceLocator.getKeplerWebServiceHttpSoap11Endpoint();

			// call execute against remote endpoint

			logMetacat.debug("WorkflowJob.execute - Executing with kar lsid:" + karLSID);

			String status = serviceEndpoint.execute(karLSID);		

			logMetacat.debug("WorkflowJob.execute - Status: " + status);

		} catch (RemoteException re) {

			String errorStr = "WorkflowJob.execute - Remote problem when trying to execute task: " + re.getMessage();

			logMetacat.error(errorStr);

			throw new JobExecutionException(errorStr); 

		} catch (ServiceException se) {

			String errorStr = "WorkflowJob.execute - Service problem when trying to execute task: " + se.getMessage();

			logMetacat.error(errorStr);

			throw new JobExecutionException(errorStr); 

		} catch (Exception e) {

			String errorStr = "WorkflowJob.execute - General problem when trying to execute task: " + e.getMessage();

			logMetacat.error(errorStr);

			throw new JobExecutionException(errorStr); 

		}

	}

	public void interrupt() {

	}

}

/**

 *  '$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.Calendar;

import java.util.Hashtable;

import java.util.HashMap;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.apache.log4j.Logger;

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

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.AccessException;

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;

import edu.ucsb.nceas.utilities.UtilException;

/**

 * @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, 

			Hashtable<String, String[]> params, String username,

			String[] groups) throws MetacatSchedulerException {

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

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

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

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

		Calendar startCal = null;

		Calendar endCal = null;

		try {

			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]);

			// kar id must exist.  Add to job params

			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]);

			// 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,

					WORKFLOW_JOB_CLASS, WORKFLOW_JOB_GROUP, jobParams, username, groups);

			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

	 */

	public void unScheduleJob(HttpServletRequest request, HttpServletResponse response,

			Hashtable<String, String[]> params, String username, String[] groups)

			throws MetacatSchedulerException {

		try {

			// workflow job id must exist

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

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

				throw new MetacatSchedulerException("SchedulerService.unScheduleJob - workflowjobid " 

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

			}

			String jobName = jobNames[0];

			// unschedule the job

			SchedulerService schedulerService = SchedulerService.getInstance();

			String xmlResult = schedulerService.unScheduleJob(jobName, username, groups);

			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

	 */

	public void reScheduleJob(HttpServletRequest request, HttpServletResponse response, 

			Hashtable<String, String[]> params, String username,

			String[] groups) throws MetacatSchedulerException {

		try {

			// workflow job id must exist

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

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

				throw new MetacatSchedulerException("WorkflowScheduler.reScheduleJob - workflowjobid field must be populated "

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

			}			

			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) {

			throw new MetacatSchedulerException("WorkflowScheduler.reScheduleJob - " 

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

		} catch (ServiceException se) {

			throw new MetacatSchedulerException("WorkflowScheduler.reScheduleJob - " 

					+ "Service issue scheduling job", se);

		} catch (ErrorSendingErrorException esee) {

			throw new MetacatSchedulerException("WorkflowScheduler.reScheduleJob - " 

					+ "Issue sending erro when scheduling 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 {

			// workflow job id must exist

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

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

				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();

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

			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();

			}

		}

	}

}

/**

 *  '$RCSfile$'

 *    Purpose: A Class that implements a metadata catalog as a java Servlet

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

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Matt Jones, Dan Higgins, Jivka Bojilova, Chad Berkley, Matthew Perry

 *

 *   '$Author: daigle $'

 *     '$Date: 2009-08-07 10:35:18 -0700 (Fri, 07 Aug 2009) $'

 * '$Revision: 5018 $'

 *

 * 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.sql.SQLException;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.Timer;

import javax.servlet.ServletConfig;

import javax.servlet.ServletContext;

import javax.servlet.ServletException;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import javax.servlet.http.HttpSession;

import org.apache.log4j.Logger;

import org.apache.log4j.PropertyConfigurator;

import edu.ucsb.nceas.metacat.database.DBConnectionPool;

import edu.ucsb.nceas.metacat.properties.PropertyService;

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

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

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

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

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

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

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

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

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

import edu.ucsb.nceas.utilities.FileUtil;

/**

 * A workflow scheduling server implemented as a Java Servlet

 *

 * Valid actions are:

 * 

 * action=scheduleWorkflow -- Schedule a workflow to be run.  Scheduling a workflow 

 *                            registers it with the scheduling engine and creates a row

 *                            in the scheduled_job table.  Note that this may be 

 *                            extracted into a separate servlet.

 *     delay -- The amount of time from now before the workflow should be run.  The 

 *              delay can be expressed in number of seconds, minutes, hours and days, 

 *              for instance 30s, 2h, etc.

 *     starttime -- The time that the workflow should first run.  If both are provided

 *                  this takes precedence over delay.  The time should be expressed as: 

 *                  MM/dd/yyyy HH:mm:ss with the timezone assumed to be that of the OS.

 *     endtime -- The time when the workflow should end. The time should be expressed as: 

 *                  MM/dd/yyyy HH:mm:ss with the timezone assumed to be that of the OS.

 *     intervalvalue -- The numeric value of the interval between runs

 *     intervalunit -- The unit of the interval between runs.  Can be s, m, h, d for 

 *                     seconds, minutes, hours and days respectively

 *     workflowid -- The lsid of the workflow that we want to schedule.  This workflow

 *                   must already exist in the database.

 *     karid -- The karid for the workflow that we want to schedule.

 *     workflowname -- The name of the workflow.

 *     forwardto -- If provided, forward to this page when processing is done.

 *     qformat -- If provided, render results using the stylesheets associated with

 *                this skin.  Default is xml.

 * action=unscheduleWorkflow -- Unschedule a workflow.  Unscheduling a workflow 

 *                            removes it from the scheduling engine and changes the 

 *                            status in the scheduled_job table to " unscheduled.  Note 

 *                            that this may be extracted into a separate servlet.

 *     workflowjobid -- The job ID for the workflow run that we want to unschedule.  This

 *                      is held in the database as scheduled_job.name

 *     forwardto -- If provided, forward to this page when processing is done.

 *     qformat -- If provided, render results using the stylesheets associated with

 *                this skin.  Default is xml.

 * action=rescheduleWorkflow -- Unschedule a workflow.  Rescheduling a workflow 

 *                            registers it with the scheduling engine and changes the 

 *                            status in the scheduled_job table to " scheduled.  Note 

 *                            that this may be extracted into a separate servlet.

 *     workflowjobid -- The job ID for the workflow run that we want to reschedule.  This

 *                      is held in the database as scheduled_job.name

 *     forwardto -- If provided, forward to this page when processing is done.

 *     qformat -- If provided, render results using the stylesheets associated with

 *                this skin.  Default is xml.

 * action=deleteScheduledWorkflow -- Delete a workflow.  Deleting a workflow 

 *                            removes it from the scheduling engine and changes the 

 *                            status in the scheduled_job table to " deleted.  Note 

 *                            that this may be extracted into a separate servlet.

 *     workflowjobid -- The job ID for the workflow run that we want to delete.  This

 *                      is held in the database as scheduled_job.name

 *     forwardto -- If provided, forward to this page when processing is done.

 *     qformat -- If provided, render results using the stylesheets associated with

 *                this skin.  Default is xml.

 *     

 */

public class WorkflowSchedulerServlet extends HttpServlet {

	private static final long serialVersionUID = 1L;

	private Timer timer = null;

    // Constants -- these should be final in a servlet

    private static String LOG_CONFIG_NAME = null;

    public static final String APPLICATION_NAME = "workflowscheduler";

    /**

     * Initialize the servlet by creating appropriate database connections

     */

    public void init(ServletConfig config) throws ServletException {

    	Logger logMetacat = Logger.getLogger(WorkflowSchedulerServlet.class);

    	try {

            super.init(config);

            ServletContext context = config.getServletContext();

            context.setAttribute("APPLICATION_NAME", APPLICATION_NAME);

            // Initialize the properties file

            String dirPath = context.getRealPath("./WEB-INF");

            LOG_CONFIG_NAME = dirPath + FileUtil.getFS() + "log4j.properties";

        	PropertyConfigurator.configureAndWatch(LOG_CONFIG_NAME);

            PropertyService.getInstance(context);

            SessionService.getInstance();

            SchedulerService.getInstance();

			// initialize DBConnection pool

			DBConnectionPool connPool = DBConnectionPool.getInstance();

			logMetacat.debug("DBConnection pool initialized: " + connPool.toString());

    	} catch (ServiceException se) {

        	String errorMessage = 

        		"Service problem while intializing WorkflowScheduler Servlet: " + se.getMessage();

            logMetacat.error(errorMessage);

            throw new ServletException(errorMessage);

        } catch (SQLException e) {

			String errorMessage = "SQL problem while intializing MetaCat Servlet: "

					+ e.getMessage();

			logMetacat.error(errorMessage);

			throw new ServletException(errorMessage);

        } 

    }

    /**

	 * Close all db connections from the pool

	 */

    public void destroy() {

    	Logger logMetacat = Logger.getLogger(WorkflowSchedulerServlet.class);

    	ServiceService.stopAllServices();

        // Close all db connection

        logMetacat.warn("Destroying WorkflowSchedulerServlet");

        timer.cancel();

//        IndexingQueue.getInstance().setMetacatRunning(false);

        DBConnectionPool.release();

    }

    /** Handle "GET" method requests from HTTP clients */

    public void doGet(HttpServletRequest request, HttpServletResponse response)

    throws ServletException, IOException {

        // Process the data and send back the response

        handleGetOrPost(request, response);

    }

    /** Handle "POST" method requests from HTTP clients */

    public void doPost(HttpServletRequest request, HttpServletResponse response)

    throws ServletException, IOException {

        // Process the data and send back the response

        handleGetOrPost(request, response);

    }

    /**

	 * Control servlet response depending on the action parameter specified

	 */

	private void handleGetOrPost(HttpServletRequest request, HttpServletResponse response)

			throws ServletException, IOException {

		Logger logMetacat = Logger.getLogger(WorkflowSchedulerServlet.class);

		// Update the last update time for this user if they are not new

		HttpSession httpSession = request.getSession(false);

		if (httpSession != null) {

			SessionService.touchSession(httpSession.getId());

		}

		/*

		 * logMetacat.debug("Connection pool size: "

		 * +connPool.getSizeOfDBConnectionPool(),10); logMetacat.debug("Free

		 * DBConnection number: "

		 */

		// If all DBConnection in the pool are free and DBConnection pool

		// size is greater than initial value, shrink the connection pool

		// size to initial value

		DBConnectionPool.shrinkDBConnectionPoolSize();

		// Debug message to print out the method which have a busy DBConnection

		try {

			DBConnectionPool pool = DBConnectionPool.getInstance();

			pool.printMethodNameHavingBusyDBConnection();

		} catch (SQLException sqle) {

			logMetacat.error("WorkflowSchedulerServlet.handleGetOrPost - error getting DBConnectionPool: "

					+ sqle.getMessage());

			sqle.printStackTrace();

		}

		try {

			String name = null;

			String[] value = null;

			Hashtable<String, String[]> params = new Hashtable<String, String[]>();

			Enumeration<String> paramlist = 

				(Enumeration<String>) request.getParameterNames();

			while (paramlist.hasMoreElements()) {

				name = paramlist.nextElement();

				value = request.getParameterValues(name);

				params.put(name, value);

			}

			// handle param is emptpy

			if (params.isEmpty() || params == null) {

				return;

			}

			// if the user clicked on the input images, decode which image

			// was clicked then set the action.

			if (params.get("action") == null) {

				PrintWriter out = response.getWriter();

				response.setContentType("text/xml");

				out.println("<?xml version=\"1.0\"?>");

				out.println("<error>");

				out.println("Action not specified");

				out.println("</error>");

				out.close();

				return;

			}

			String action = (params.get("action"))[0];

			logMetacat.info("WorkflowSchedulerServlet.handleGetOrPost - Action is: " + action);

			// This block handles session management for the servlet

			// by looking up the current session information for all actions

			// other than "login" and "logout"

			String userName = null;

			String[] groupNames = null;

			name = null;

			// handle login action

			if (action.equals("login")) {

				// PrintWriter out = response.getWriter();

				// handleLoginAction(out, params, request, response);

				// out.close();

				// handle logout action

			} else if (action.equals("logout")) {

				// PrintWriter out = response.getWriter();

				// handleLogoutAction(out, params, request, response);

				// out.close();

				// handle shrink DBConnection request

			} else if (action.equals("shrink")) {

				PrintWriter out = response.getWriter();

				boolean success = false;

				// If all DBConnection in the pool are free and DBConnection

				// pool

				// size is greater than initial value, shrink the connection

				// pool

				// size to initial value

				success = DBConnectionPool.shrinkConnectionPoolSize();

				if (success) {

					// if successfully shrink the pool size to initial value

					out.println("DBConnection Pool shrunk successfully.");

				}// if

				else {

					out.println("DBConnection pool not shrunk successfully.");

				}

				// close out put

				out.close();

				// aware of session expiration on every request

			} else {

				SessionData sessionData = RequestUtil.getSessionData(request);

				userName = sessionData.getUserName();

				// password = sessionData.getPassword();

				groupNames = sessionData.getGroupNames();

				// sessionId = sessionData.getId();

				logMetacat.info("WorkflowSchedulerServlet.handleGetOrPost - The user is : " + userName);

			}

			if (action.equals("scheduleWorkflow")) {

				try {

					WorkflowScheduler.getInstance().scheduleJob(request, response,

							params, userName, groupNames);

					return;

				} catch (BaseException be) {

					logMetacat.error("WorkflowSchedulerServlet.handleGetOrPost - error when scheduling" 

							+ "workflow", be);

					ResponseUtil.sendErrorXML(response,

							ResponseUtil.SCHEDULE_WORKFLOW_ERROR, be);

					return;

				}

			} else if (action.equals("unscheduleWorkflow")) {

				try {

					WorkflowScheduler.getInstance().unScheduleJob(request, response,

							params, userName, groupNames);

					return;

				} catch (BaseException be) {

					logMetacat.error("WorkflowSchedulerServlet.handleGetOrPost - error when unscheduling" 

							+ "workflow", be);

					ResponseUtil.sendErrorXML(response,

							ResponseUtil.UNSCHEDULE_WORKFLOW_ERROR, be);

					return;

				}

			} else if (action.equals("rescheduleWorkflow")) {

				try {

					WorkflowScheduler.getInstance().reScheduleJob(request, response,

							params, userName, groupNames);

					return;

				} catch (BaseException be) {

					logMetacat.error("WorkflowSchedulerServlet.handleGetOrPost - error when rescheduling" 

							+ "workflow", be);

					ResponseUtil.sendErrorXML(response,

							ResponseUtil.RESCHEDULE_WORKFLOW_ERROR, be);

					return;

				}

			} else if (action.equals("getScheduledWorkflow")) {

				try {

					WorkflowScheduler.getInstance().getJobs(request, response, params,

							userName, groupNames);

					return;

				} catch (BaseException be) {

					logMetacat.error("WorkflowSchedulerServlet.handleGetOrPost - error when getting" 

							+ "scheduled workflows", be);

					ResponseUtil.sendErrorXML(response,

							ResponseUtil.GET_SCHEDULED_WORKFLOW_ERROR, be);

					return;

				}

			} else if (action.equals("deleteScheduledWorkflow")) {

				try {

					WorkflowScheduler.getInstance().deleteJob(request, response, params,

							userName, groupNames);

					return;

				} catch (BaseException be) {

					logMetacat.error("WorkflowSchedulerServlet.handleGetOrPost - error when deleting" 

							+ "workflow", be);

					ResponseUtil.sendErrorXML(response,

							ResponseUtil.DELETE_SCHEDULED_WORKFLOW_ERROR, be);

					return;

				}

			} else {

				logMetacat.error("WorkflowSchedulerServlet.handleGetOrPost - unregistered action: " 

						+ action);

				PrintWriter out = response.getWriter();

				out.println("<?xml version=\"1.0\"?>");

				out.println("<error>");

				out.println("Error: action not registered.  Please report this error.");

				out.println("</error>");

				out.close();

			}

		} catch (ErrorSendingErrorException esee) {

			String errorString = "WorkflowSchedulerServlet.handleGetOrPost - Error sending error message: " + esee.getMessage();

			logMetacat.error(errorString);

			throw new ServletException(errorString);

		}

	}

// // LOGIN & LOGOUT SECTION

// /**

// * Handle the login request. Create a new session object. Do user

//	 * authentication through the session.

//	 */

//    private void handleLoginAction(PrintWriter out, Hashtable<String, String[]> params,

//            HttpServletRequest request, HttpServletResponse response) {

//        Logger logMetacat = Logger.getLogger(WorkflowSchedulerServlet.class);

//        AuthSession sess = null;

//        

//        if(params.get("username") == null){

//            response.setContentType("text/xml");

//            out.println("<?xml version=\"1.0\"?>");

//            out.println("<error>");

//            out.println("Username not specified");

//            out.println("</error>");

//            return;

//        }

//        

//        // }

//        

//        if(params.get("password") == null){

//            response.setContentType("text/xml");

//            out.println("<?xml version=\"1.0\"?>");

//            out.println("<error>");

//            out.println("Password not specified");

//            out.println("</error>");

//            return;

//        }

//        

//        String un = (params.get("username"))[0];

//        logMetacat.info("user " + un + " is trying to login");

//        String pw = (params.get("password"))[0];

//        

//        String qformat = "xml";

//        if(params.get("qformat") != null){

//            qformat = (params.get("qformat"))[0];

//        }

//        

//        try {

//            sess = new AuthSession();

//        } catch (Exception e) {

//        	String errorMsg = "Problem in WorkflowSchedulerServlet.handleLoginAction() authenicating session: "

//                + e.getMessage();

//            logMetacat.error(errorMsg);

//            out.println(errorMsg);

//            return;

//        }

//        boolean isValid = sess.authenticate(request, un, pw);

//        

//        //if it is authernticate is true, store the session

//        if (isValid) {

//            HttpSession session = sess.getSessions();

//            String id = session.getId();

//            logMetacat.debug("Store session id " + id

//                    + " which has username" + session.getAttribute("username")

//                    + " into hash in login method");

//            try {

//				SessionService.registerSession(id, (String) session

//						.getAttribute("username"), (String[]) session

//						.getAttribute("groupnames"), (String) session

//						.getAttribute("password"));

//			} catch (ServiceException se) {

//				String errorMsg = "Problem in WorkflowSchedulerServlet.handleLoginAction() registering session: "

//						+ se.getMessage();

//				logMetacat.error(errorMsg);

//				out.println(errorMsg);

//				return;

//			}

//        }

//        

//        // format and transform the output

//        if (qformat.equals("xml")) {

//            response.setContentType("text/xml");

//            out.println(sess.getMessage());

//        } else {

//            try {

//                DBTransform trans = new DBTransform();

//                response.setContentType("text/html");

//                trans.transformXMLDocument(sess.getMessage(),

//                        "-//NCEAS//login//EN", "-//W3C//HTML//EN", qformat,

//                        out, null, null);

//            } catch (Exception e) {               

//                logMetacat.error("Error in WorkflowSchedulerServlet.handleLoginAction: "

//                        + e.getMessage());

//            }

//        }

//    }

//    

//    /**

//     * Handle the logout request. Close the connection.

//     */

//    private void handleLogoutAction(PrintWriter out, Hashtable<String, String[]> params,

//            HttpServletRequest request, HttpServletResponse response) {

//        Logger logMetacat = Logger.getLogger(WorkflowSchedulerServlet.class);

//        String qformat = "xml";

//        if(params.get("qformat") != null){

//            qformat = params.get("qformat")[0];

//        }

//        

//        // close the connection

//        HttpSession sess = request.getSession(false);

//        logMetacat.info("After get session in logout request");

//        if (sess != null) {

//            logMetacat.info("The session id " + sess.getId()

//            + " will be invalidate in logout action");

//            logMetacat.info("The session contains user "

//                    + sess.getAttribute("username")

//                    + " will be invalidate in logout action");

//            sess.invalidate();

//            SessionService.unRegisterSession(sess.getId());

//        }

//        

//        // produce output

//        StringBuffer output = new StringBuffer();

//        output.append("<?xml version=\"1.0\"?>");

//        output.append("<logout>");

//        output.append("User logged out");

//        output.append("</logout>");

//        

//        //format and transform the output

//        if (qformat.equals("xml")) {

//            response.setContentType("text/xml");

//            out.println(output.toString());

//        } else {

//            try {

//                DBTransform trans = new DBTransform();

//                response.setContentType("text/html");

//                trans.transformXMLDocument(output.toString(),

//                        "-//NCEAS//login//EN", "-//W3C//HTML//EN", qformat,

//                        out, null, null);

//            } catch (Exception e) {

//                logMetacat.error(

//                        "Error in WorkflowSchedulerServlet.handleLogoutAction"

//                        + e.getMessage());

//            }

//        }

//    }

}