Metacat

/**

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

 *     workflowjobname -- 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.

 *     workflowjobname -- 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.

 *     workflowjobname -- 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;

    // 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("WorkflowSchedulerServlet.init - DBConnection pool initialized: " + connPool.toString());

    	} catch (ServiceException se) {

        	String errorMessage = 

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

            logMetacat.error(errorMessage);

            throw new ServletException(errorMessage);

        } catch (SQLException e) {

			String errorMessage = "WorkflowSchedulerServlet.init - SQL problem while intializing WorkflowScheduler 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);

    	try {

    		SchedulerService.getInstance().stop();

    	} catch (ServiceException se) {

    		logMetacat.warn("WorkflowSchedulerServlet.destroy - Could not stop scheduler service: " + se.getMessage());

    	}

        // Close all db connection

        logMetacat.warn("WorkflowSchedulerServlet.destroy - Destroying WorkflowSchedulerServlet");

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

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

//            }

//        }

//    }

}