/ - Diff - Metacat - Ecoinformatics Redmine

     /**
      *  '$RCSfile$'
      *    Purpose: An Exception thrown when an error occurs because an
      *             AccessionNumber was invalid or used incorrectly
      *  Copyright: 2008 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.shared;
     /**
      * Exception thrown when an error occurs in a configuration administrative
      * class
      */
     public class AccessException extends Exception {
     	private static final long serialVersionUID = -8436697355629175917L;
     	/**
     	 * Create a new AccessException.
+    	 *
     	 * @param message The error or warning message.
     	 */
     	public AccessException(String message) {
     		super(message);
+    	}
+    }

     /**
      *  '$RCSfile$'
      *    Purpose: A Class that manages database access
      *             information.
      *  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-23 13:56:56 -0800 (Mon, 23 Mar 2009) $'
      * '$Revision: 4854 $'
+     *
      * 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.shared;
     import java.sql.PreparedStatement;
     import java.sql.ResultSet;
     import java.sql.SQLException;
     import edu.ucsb.nceas.metacat.DBConnection;
     import edu.ucsb.nceas.metacat.DBConnectionPool;
     public class BaseAccess {
     	protected DBConnection conn = null;
         protected int serialNumber = -1;
         protected PreparedStatement pstmt = null;
         protected ResultSet rs = null;
         protected BaseAccess(String methodName) throws AccessException {
             //check out DBConnection
         	try {
         		conn = DBConnectionPool.
                     	getDBConnection("methodName");
         		serialNumber = conn.getCheckOutSerialNumber();
         	} catch (SQLException sqle) {
         		throw new AccessException("Could not get connection from DB connection pool: "
         				+ sqle.getMessage());
+        	}
+        }
         protected ResultSet select(PreparedStatement pstmt) throws AccessException {
         	try {
         		pstmt.execute();
             	rs = pstmt.getResultSet();
         	} catch (SQLException sqle) {
         		throw new AccessException("Could not perform select: " + pstmt.toString()
         				+ sqle.getMessage());
+        	}
         	return rs;
+        }
+    }

     /**
      *  '$RCSfile$'
      *    Purpose: A Class that holds the data from the scheduled_task
      *             table in the database.
      *  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-23 13:56:56 -0800 (Mon, 23 Mar 2009) $'
      * '$Revision: 4854 $'
+     *
      * 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.shared;
     import java.sql.Timestamp;
     public class BaseDAO {
     	private Long _id;
     	private Timestamp _createTime;
     	private Timestamp _modTime;
     	private String _status;
     	public Long getId() {
     		return _id;
+    	}
     	public void setId(Long id) {
     		_id = id;
+    	}
     	public Timestamp getCreateTime() {
     		return _createTime;
+    	}
     	public void setCreateTime(Timestamp createTime) {
     		_createTime = createTime;
+    	}
     	public Timestamp getModTime() {
     		return _modTime;
+    	}
     	public void setModTime(Timestamp modTime) {
     		_modTime = modTime;
+    	}
     	public String getStatus() {
     		return _status;
+    	}
     	public void setStatus(String status) {
     		_status = status;
+    	}
+    }

     /**
      *  '$RCSfile$'
      *    Purpose: A Class that implements system utility methods
      *  Copyright: 2008 Regents of the University of California and the
      *             National Center for Ecological Analysis and Synthesis
      *    Authors: Michael Daigle
+     *
      *   '$Author: daigle $'
      *     '$Date: 2009-03-23 13:56:56 -0800 (Mon, 23 Mar 2009) $'
      * '$Revision: 4854 $'
+     *
      * 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.workflow;
     import java.util.Hashtable;
     import org.apache.log4j.Logger;
     public class WorkflowEngineClient implements WorkflowClientInterface {
     	private static Logger logMetacat = Logger.getLogger(WorkflowEngineClient.class);
     	public void execute(String workflowName, Hashtable<String, String> additionalParams) {
     		// do execution stuff here
+    	}
     	public String getStatus(String workflowId) {
     		String statusXML = "";
     		// do status stuff here
     		return statusXML;
+    	}
+     }

     /**
      *  '$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.metacat.workflow;
     import org.quartz.JobExecutionContext;
     import org.quartz.JobExecutionException;
     import edu.ucsb.nceas.metacat.scheduler.ScheduledJobInterface;
     public class WorkflowJob implements ScheduledJobInterface {
     	public void execute(JobExecutionContext context) throws JobExecutionException {
+    	}
     	public void interrupt() {
+    	}
+    }

     /**
      *  '$RCSfile$'
      *    Purpose: A Class that loads eml-access.xml file containing ACL
      *             for a metadata document into relational DB
      *  Copyright: 2000 Regents of the University of California and the
      *             National Center for Ecological Analysis and Synthesis
      *    Authors: Jivka Bojilova
+     *
      *   '$Author: daigle $'
      *     '$Date: 2009-03-25 14:04:06 -0800 (Wed, 25 Mar 2009) $'
      * '$Revision: 4863 $'
+     *
      * 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.workflow;
     import java.util.Hashtable;
     /**
      * This interface will handle the access control for different documents:
      * the package-orented, single eml2 document and other single file
      */
     public interface WorkflowClientInterface
+    {
     	public void execute(String workflowName, Hashtable<String, String> additionalParams);
     	public String getStatus(String workflowId);
+    }

     package edu.ucsb.nceas.metacat.util;
     import java.io.IOException;
     import java.util.Vector;
     import java.util.regex.Matcher;
     import java.util.regex.Pattern;
-...
+    	 *
     	 * @return a string holding the backup location.  Null if none could be found.
     	 */
     	public static String getStoredBackupDir() throws UtilException {
     	public static String getStoredBackupDir() throws MetacatUtilException {
     		String applicationContext = null;
     		try {
     			applicationContext = ServiceService.getRealApplicationContext();
-...
     		return null;
+    	}
     	public static void writeStoredBackupFile(String backupPath) throws UtilException {
     	public static void writeStoredBackupFile(String backupPath) throws MetacatUtilException {
     		String applicationContext = null;
     		try {
     			applicationContext = ServiceService.getRealApplicationContext();
-...
     		} catch (UtilException ue) {
     			logMetacat.warn("Utility error writing backup file: " + ue.getMessage());
     		} catch (IOException ioe) {
     			logMetacat.warn("I/O error finding backup location: " + ioe.getMessage());
     		} catch (ServiceException se) {
     			logMetacat.warn("Service error getting real application context: " + se.getMessage());
+    		}
-...
+    	 *
     	 * @return a string holding the backup directory path
     	 */
     	public static String discoverExternalDir() throws UtilException {
     	public static String discoverExternalDir() throws MetacatUtilException {
     		String applicationContext = null;
     		try {
-...
     				return userHomeMetacatDir;
+    			}
     		} catch (IOException ioe) {
     			logMetacat.warn("I/O proplem finding backup location: " + ioe.getMessage());
     		} catch (ServiceException se) {
     			logMetacat.warn("Could not get real application context: " + se.getMessage());
     		} catch (UtilException ue) {
     			logMetacat.warn("Could not create directory: " + ue.getMessage());
     		} catch (PropertyNotFoundException pnfe) {
     			logMetacat.warn("Could not get default backup base dir property: "
     					+ pnfe.getMessage());
-...
     				FileUtil.createDirectory(storedBackupLocDir);
     				FileUtil.writeFile(storedBackupLocFile, externalDir);
     			} catch (IOException ioe) {
     				logMetacat.error("I/O error while trying to write stored backup directory: "
     							+ storedBackupLocFile + " : " + ioe.getMessage());
     			} catch (ServiceException se) {
     				logMetacat.error("Could not get real application directory while trying to write "
     							+ "stored backup directory: "+ storedBackupLocFile + " : " + se.getMessage());

src/edu/ucsb/nceas/metacat/util/RequestUtil.java
312	312	public static void setUserId(HttpServletRequest request, String userId) {
313	313	request.getSession().setAttribute("userId", userId);
314	314	}
	315
	316
315	317	}

     /**
      *  '$RCSfile$'
      *    Purpose: A Class that implements administrative methods
      *  Copyright: 2008 Regents of the University of California and the
      *             National Center for Ecological Analysis and Synthesis
      *    Authors: Michael Daigle
+     *
      *   '$Author: daigle $'
      *     '$Date: 2008-08-22 16:26:10 -0700 (Fri, 22 Aug 2008) $'
      * '$Revision: 4299 $'
+     *
      * 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.util;
     import java.io.IOException;
     import java.io.PrintWriter;
     import java.util.Hashtable;
     import javax.servlet.http.HttpServletResponse;
     import org.apache.log4j.Logger;
     public class ErrorUtil {
     	private static Logger logMetacat = Logger.getLogger(RequestUtil.class);
     	// 101XXX - general errors
     	public static Long GENERAL_UTILITY_ERROR = new Long(101001);
     	public static Long METACAT_UTILITY_ERROR = new Long(101002);
     	// 104XXX - property errors
     	public static Long PROPERTY_NOT_FOUND = new Long(104001);
     	// 105XXX - permission errors
     	public static Long NO_READ_PERMISSION = new Long(105001);
     	// errorCodes is a lookup table for generic messages for each code.  It
     	// is better to use the sendError() versions that accept an explicit
     	// error message;
     	static Hashtable<Long, String> errorCodes = new Hashtable<Long, String>();
     	static {
     		errorCodes.put(GENERAL_UTILITY_ERROR, "General utility error");
     		errorCodes.put(METACAT_UTILITY_ERROR, "Metacat utility error");
     		errorCodes.put(PROPERTY_NOT_FOUND, "Property not found");
     		errorCodes.put(NO_READ_PERMISSION, "Read permission denied for user");
+    	}
     	/**
     	 * private constructor - all methods are static so there is no
          * no need to instantiate.
     	 */
     	private ErrorUtil() {}
     	public static void sendError(HttpServletResponse response, Long errorCode, String errorMessage)
     		throws ErrorSendingErrorException {
     		PrintWriter out = null;
     		try {
     			out = response.getWriter();
     			response.setContentType("text/xml");
     			out.println("<?xml version=\"1.0\"?>");
     			out.println("<error>");
     			out.println("<code>" + errorCode + "</code>");
     			out.println("<message>" + errorMessage + "</message>");
     			out.println("</error>");
     		} catch (IOException ioe) {
     			throw new ErrorSendingErrorException("I/O error when returning error: "
     					+ errorCode + " : " + errorMessage);
     		} finally {
     			if (out != null) {
     				out.close();
+    			}
+    		}
+    	}
     	public static void sendError(HttpServletResponse response, Long errorCode)
     		throws ErrorSendingErrorException {
     		PrintWriter out = null;
     		try {
     			out = response.getWriter();
     			response.setContentType("text/xml");
     			out.println("<?xml version=\"1.0\"?>");
     			out.println("<error>");
     			out.println("<code>" + errorCode + "</code>");
     			out.println("<message>" + errorCodes.get(errorCode) + "</message>");
     			out.println("</error>");
     		} catch (IOException ioe) {
     			throw new ErrorSendingErrorException("I/O error when returning error: "
     					+ errorCode);
     		} finally {
     			if (out != null) {
     				out.close();
+    			}
     		} out.close();
+    	}
     	public static void sendError(HttpServletResponse response, PrintWriter out,
     			Long errorCode, String errorMessage) throws ErrorSendingErrorException {
     		response.setContentType("text/xml");
     		out.println("<?xml version=\"1.0\"?>");
     		out.println("<error>");
     		out.println("<code>" + errorCode + "</code>");
     		out.println("<message>" + errorMessage + "</message>");
     		out.println("</error>");
+    	}
     	public static void sendError(HttpServletResponse response, PrintWriter out,
     			Long errorCode) throws ErrorSendingErrorException {
     		response.setContentType("text/xml");
     		out.println("<?xml version=\"1.0\"?>");
     		out.println("<error>");
     		out.println("<code>" + errorCode + "</code>");
     		out.println("<message>" + errorCodes.get(errorCode) + "</message>");
     		out.println("</error>");
+    	}
+    }

     /**
      *  '$RCSfile$'
      *    Purpose: An Exception thrown when an error occurs because an
      *             AccessionNumber was invalid or used incorrectly
      *  Copyright: 2008 Regents of the University of California and the
      *             National Center for Ecological Analysis and Synthesis
      *    Authors: Michael Daigle
+     *
      *   '$Author: daigle $'
      *     '$Date: 2009-03-23 13:56:56 -0800 (Mon, 23 Mar 2009) $'
      * '$Revision: 4854 $'
+     *
      * 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.util;
     /**
      * Exception thrown when an error occurs in a utility method
      */
     public class ErrorSendingErrorException extends Exception {
     	private static final long serialVersionUID = 2470535012803585651L;
     	/**
     	 * Create a new AdminException.
+    	 *
     	 * @param message The error or warning message.
     	 */
     	public ErrorSendingErrorException(String message) {
     		super(message);
+    	}
+    }

     package edu.ucsb.nceas.metacat.util;
     import java.io.FileInputStream;
     import java.io.FileNotFoundException;
     import java.io.IOException;
     import java.io.InputStream;
     import java.io.OutputStream;
     import javax.servlet.http.HttpServletRequest;
     import javax.servlet.http.HttpServletResponse;
     import org.apache.log4j.Logger;
     import edu.ucsb.nceas.utilities.FileUtil;
     public class ResponseUtil {
     	private static Logger logMetacat = Logger.getLogger(ResponseUtil.class);
     	private static int DEFAULT_BUFFER_SIZE = 4 * 1024; // 4K buffer
     	/**
     	 * private constructor - all methods are static so there is no
          * no need to instantiate.
-...
     	 *            the context-relative URL to which the request is forwarded
     	 */
     	public static void redirectResponse(HttpServletRequest request,
     			HttpServletResponse response, String destination)
     			throws IOException {
     		logMetacat.debug("Redirecting response to " + request.getContextPath() + destination);
     		response.sendRedirect(request.getContextPath() + destination);
     			HttpServletResponse response, String destination) throws MetacatUtilException {
     		try {
     			logMetacat.debug("Redirecting response to " + request.getContextPath() + destination);
     			response.sendRedirect(request.getContextPath() + destination);
     		} catch (IOException ioe) {
     			throw new MetacatUtilException("I/O error when redirecting response to: " + destination);
+    		}
+    	}
     	public static void writeFileToOutput(HttpServletResponse response, String fileDir, String fileName)
     		throws MetacatUtilException {
     		writeFileToOutput(response, fileDir, fileName, DEFAULT_BUFFER_SIZE);
+    	}
     	public static void writeFileToOutput(HttpServletResponse response, String fileDir, String fileName, int bufferSize)
     			throws MetacatUtilException {
     		String filePath = "";
     		try {
     			filePath = fileDir + FileUtil.getFS() + fileName;
     			int lastFileSep = fileName.lastIndexOf(FileUtil.getFS());
     			String shortFileName = fileName.substring(lastFileSep + 1, fileName.length());
     			response.setHeader("Content-Disposition", "attachment; filename=\"" + shortFileName + "\"");
     			InputStream inputStream = new FileInputStream(filePath);
     			OutputStream outputStream = response.getOutputStream();
     			byte[] byteBuffer = new byte[bufferSize];
     			int b = 0;
     			while ((b = inputStream.read(byteBuffer)) != -1) {
     				outputStream.write(byteBuffer, 0, b);
+    			}
     		} catch (FileNotFoundException fnfe) {
     			throw new MetacatUtilException("Error finding file: " + filePath
     					+ " when writing to output");
     		} catch (IOException ioe) {
     			throw new MetacatUtilException("I/O Error when writing: " + filePath
     					+ "  to output");
+    		}
+    	}
+    }

     /**
      *  '$RCSfile$'
      *    Purpose: A Class that holds the data from the scheduled_task
      *             table in the database.
      *  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-23 13:56:56 -0800 (Mon, 23 Mar 2009) $'
      * '$Revision: 4854 $'
+     *
      * 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.sql.Timestamp;
     import edu.ucsb.nceas.shared.BaseDAO;
     public class ScheduledJobDAO extends BaseDAO {
     	public static String SECONDLY = "secondly";
     	public static String MINUTELY = "minutely";
     	public static String HOURLY = "hourly";
     	public static String DAILY = "daily";
     	public static String WEEKLY = "weekly";
     	private String _name;
     	private String _triggerName;
     	private String _groupName;
     	private String _className;
     	private Timestamp _startTime;
     	private int _interval;
     	public String getName() {
     		return _name;
+    	}
     	public void setName(String name) {
     		_name = name;
+    	}
     	public String getTriggerName() {
     		return _triggerName;
+    	}
     	public void setTriggerName(String triggerName) {
     		_triggerName = triggerName;
+    	}
     	public String getGroupName() {
     		return _groupName;
+    	}
     	public void setGroupName(String groupName) {
     		_groupName = groupName;
+    	}
     	public String getClassName() {
     		return _className;
+    	}
     	public void setClassName(String className) {
     		_className = className;
+    	}
     	public Timestamp getStartTime() {
     		return _startTime;
+    	}
     	public void setStartTime(Timestamp startTime) {
     		_startTime = startTime;
+    	}
     	public int getInterval() {
     		return _interval;
+    	}
     	public void setInterval(int interval) {
     		_interval = interval;
+    	}
+    }

     /**
      *  '$RCSfile$'
      *    Purpose: A Class that handles scheduling tasks
      *  Copyright: 2009 Regents of the University of California and the
      *             National Center for Ecological Analysis and Synthesis
      *    Authors: Michael Daigle
+     *
      *   '$Author: daigle $'
      *     '$Date: 2009-03-25 13:41:15 -0800 (Wed, 25 Mar 2009) $'
      * '$Revision: 4861 $'
+     *
      * This program is free software; you can redistribute it and/or modify
      * it under the terms of the GNU General Public License as published by
      * the Free Software Foundation; either version 2 of the License, or
      * (at your option) any later version.
+     *
      * This program is distributed in the hope that it will be useful,
      * but WITHOUT ANY WARRANTY; without even the implied warranty of
      * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      * GNU General Public License for more details.
+     *
      * You should have received a copy of the GNU General Public License
      * along with this program; if not, write to the Free Software
      * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
      */
     package edu.ucsb.nceas.metacat.scheduler;
     import java.text.DateFormat;
     import java.text.ParseException;
     import java.util.Arrays;
     import java.util.Calendar;
     import java.util.Date;
     import java.util.Enumeration;
     import java.util.Hashtable;
     import java.util.Vector;
     import javax.servlet.http.HttpServletRequest;
     import javax.servlet.http.HttpServletResponse;
     import org.apache.log4j.Logger;
     import org.quartz.Job;
     import org.quartz.JobDetail;
     import org.quartz.Scheduler;
     import org.quartz.SchedulerException;
     import org.quartz.SchedulerFactory;
     import org.quartz.Trigger;
     import org.quartz.TriggerUtils;
     import edu.ucsb.nceas.metacat.service.BaseService;
     import edu.ucsb.nceas.metacat.service.ServiceException;
     import edu.ucsb.nceas.shared.AccessException;
     public class SchedulerService extends BaseService {
     	private static SchedulerService schedulerService = null;
     	private static Logger logMetacat = Logger.getLogger(SchedulerService.class);
     	private static Scheduler sched = null;
     	static Hashtable<String, String> jobClassNames = new Hashtable<String, String>();
     	static {
     		jobClassNames.put("workflow", "edu.ucsb.nceas.metacat.workflow.WorkflowJob");
+    	}
     	/**
     	 * private constructor since this is a singleton
     	 */
     	private SchedulerService() throws ServiceException {}
     	/**
     	 * Get the single instance of SchedulerService.
+    	 *
     	 * @return the single instance of SchedulerService
     	 */
     	public static SchedulerService getInstance() throws ServiceException {
     		if (schedulerService == null) {
     			schedulerService = new SchedulerService();
+    		}
     		return schedulerService;
+    	}
     	public boolean refreshable() {
     		return true;
+    	}
     	protected void doRefresh() throws ServiceException {
     		stop();
+    	}
     	protected void start() throws ServiceException {
     		try {
     			SchedulerFactory schedFact = new org.quartz.impl.StdSchedulerFactory();
     			sched = schedFact.getScheduler();
     			// read jobs from db here.
     			// then add jobs to sched.
     			sched.start();
     		} catch (SchedulerException se) {
     			throw new ServiceException("Could not start scheduler: " + se.getMessage());
+    		}
+    	}
     	protected void stop() throws ServiceException {
     		try {
     			sched.shutdown(true);
     			sched = null;
     		} catch (SchedulerException se) {
     			throw new ServiceException("Could not shut down scheduler: " + se.getMessage());
+    		}
+    	}
     	protected Vector<String> getStatus() throws ServiceException {
     		return new Vector<String>();
+    	}
     	public String scheduleHandler(Hashtable<String, String[]> params,
                 HttpServletRequest request, HttpServletResponse response,
                 String username, String[] groups) throws ServiceException {
     		String returnString = "";
             String[] categories = params.get("category");
             if (categories == null || categories.length == 0) {
             	throw new ServiceException("SchedulerService.scheduleHandler - Category field "
             			+ "must be populated in scheduler parameters");
+            }
             String category = categories[0];
             if (category.equals("schedule")) {
         		Calendar startCal = null;
                 Hashtable<String, String> jobParams = new Hashtable<String, String>();
         		String jobTypes[] = params.get("type");
                 if (jobTypes == null || jobTypes.length == 0) {
                 	throw new ServiceException("SchedulerService.scheduleJob - Type field must be populated "
                 			+ "in scheduler parameters when scheduling job.");
+                }
                 String delays[] = params.get("delay");
         		String startTimes[] = params.get("starttime");
                 try {
         			if (delays != null && delays.length > 0) {
         				startCal = getStartDateFromDelay(delays[0]);
         			} else if (startTimes != null && startTimes.length > 0) {
         				Date startDate = DateFormat.getInstance().parse(startTimes[0]);
         				startCal = Calendar.getInstance();
         				startCal.setTime(startDate);
         			} else {
         				throw new ServiceException("SchedulerService.scheduleJob -  Either delay or starttime  "
         						+ "field must be populated in scheduler parameters when scheduling job.");
+        			}
         		} catch (ParseException pe) {
         			throw new ServiceException("SchedulerService.scheduleJob - Could not parse start time "
         					+ startTimes[0] + " : " + pe.getMessage());
+        		}
                 String intervals[] = params.get("interval");
                 if (intervals == null || intervals.length == 0) {
                 	throw new ServiceException("SchedulerService.scheduleJob - Interval field must be populated "
                 			+ "in scheduler parameters when scheduling job.");
+                }
                 String interval = intervals[0];
                 Enumeration<String> paramNames = params.keys();
                 while (paramNames.hasMoreElements()) {
                 	String paramName = paramNames.nextElement();
                 	if (paramName.startsWith("jobparam_")) {
                 		jobParams.put(paramName.substring(8), params.get(paramName)[0]);
+                	}
+                }
                 String jobType = jobTypes[0];
                 String jobName = jobType + Calendar.getInstance().getTimeInMillis();
             	returnString = scheduleJob(jobName, startCal, interval, jobType, jobParams);
             } else if (category.equals("unschedule")) {
             	String jobNames[] = params.get("jobName");
             	if (jobNames == null || jobNames.length == 0) {
             		throw new ServiceException("SchedulerService.scheduleJob - Job ID field must be populated "
                 			+ "in scheduler parameters when unscheduling job.");
+            	}
             	unscheduleJob(jobNames[0]);
             } else if (category.equals("delete")) {
     //        	deleteJob(params);
+            }
             return returnString;
+    	}
     	public String scheduleJob(String jobName, Calendar startCal, String interval,
     			String jobType, Hashtable<String, String> jobParams) throws ServiceException {
             Class<Job> jobClass = null;
             String className = jobClassNames.get(jobType);
             if (className == null) {
             	throw new ServiceException("SchedulerService.scheduleJob - Type: " + jobType
             			+ " is not registered as a valid job type");
+            }
             logMetacat.info("Scheduling job -- name: " + jobName + ", class: " + className
             		+ ", start time: " + startCal.toString() + ", interval: " + interval);
             try {
             	jobClass = (Class<Job>)Class.forName(jobType + "Job");
             } catch (ClassNotFoundException cnfe) {
             	throw new ServiceException("SchedulerService.scheduleJob - Could not find class with name: "
             			+ jobType + "Job");
+            }
     		char intervalUnit = interval.trim().charAt(interval.length());
     		String intervalStrValue = interval.trim().substring(0, interval.length() - 1);
     		int intervalValue;
     		try {
     			intervalValue = Integer.parseInt(intervalStrValue);
     		} catch (NumberFormatException nfe) {
     			throw new ServiceException("SchedulerService.scheduleJob - Could not parse interval value "
     					+ "into an integer: " + intervalStrValue);
+    		}
     		switch (intervalUnit) {
     		case 's':
     		case 'S':
     			scheduleSecondlyJob(jobName, jobClass, startCal, intervalValue, jobType);
     			break;
     		case 'm':
     		case 'M':
     			scheduleMinutelyJob(jobName, jobClass, startCal, intervalValue, jobType);
     			break;
     		case 'h':
     		case 'H':
     			scheduleHourlyJob(jobName, jobClass, startCal, intervalValue, jobType);
     			break;
     		case 'd':
     		case 'D':
     			scheduleDailyJob(jobName, jobClass, startCal, intervalValue, jobType);
     			break;
     		default:
     			throw new ServiceException("SchedulerService.scheduleJob - Could not interpret interval unit: "
     					+ intervalUnit + ". Unit must be s, m, h or d");
+    		}
     		try {
     			ScheduledJobAccess jobAccess = new ScheduledJobAccess();
     			jobAccess.createJob(jobName, jobClass, startCal, intervalValue, jobParams);
     		} catch (AccessException ae) {
     			try {
     				deleteJob(jobName);
     			} catch (ServiceException se) {
     				// Not much we can do here but log this
     				logMetacat.error("An access exception was thrown when writing job: " + jobName
     						+ "to the db, and another exception was thrown when trying to remove the "
     						+ "job from the scheduler.  The db and scheduler may be out of sync");
+    			}
     			throw new ServiceException("SchedulerService.scheduleJob - Error accessing db: "
     					+ ae.getMessage());
+    		}
     		return jobName;
+    	}
     	public void unscheduleJob(String jobName) throws ServiceException {
     		try {
     			ScheduledJobAccess jobAccess = new ScheduledJobAccess();
     			ScheduledJobDAO jobDAO = jobAccess.getJobByName(jobName);
     			sched.unscheduleJob(jobDAO.getName(), jobDAO.getGroupName());
     			jobDAO.setStatus(ScheduledJobInterface.STATE_UNSHCEDULED);
     			jobAccess.updateJobStatus(jobDAO);
     		} catch (SchedulerException se) {
     			throw new ServiceException("SchedulerService.unscheduleJob - Could not create "
     							+ "scheduled job because of service issue: " + se.getMessage());
     		} catch (AccessException ae) {
     			throw new ServiceException("SchedulerService.unscheduleJob - Could not create "
     							+ "scheduled job because of db access issue: " + ae.getMessage());
+    		}
+    	}
     	public void deleteJob(String jobName) throws ServiceException {
     		String groupName = "";
     		try {
     			ScheduledJobAccess jobAccess = new ScheduledJobAccess();
     			ScheduledJobDAO jobDAO = jobAccess.getJobByName(jobName);
     			groupName = jobDAO.getGroupName();
     			sched.deleteJob(jobName, groupName);
     		} catch (SchedulerException se) {
     			throw new ServiceException("SchedulerService.deleteJob - Could not delete job: "
     					+ jobName + " for group: " + groupName + " : " + se.getMessage());
     		} catch (AccessException ae) {
     			throw new ServiceException("SchedulerService.deleteJob - Could not delete "
     					+ "scheduled job because of db access issue: " + ae.getMessage());
+    }
+    	}
     	public Vector<String> getJobInfo(String groupName) throws ServiceException {
     		Vector<String> returnVector = new Vector<String>();
     		try {
     			if (groupName.equalsIgnoreCase("All")) {
     				String[] groupNames = sched.getJobGroupNames();
     				for (int i = 0; i < groupNames.length; i++) {
     					returnVector.addAll(Arrays.asList(sched.getJobNames(groupNames[i])));
+    				}
     			} else {
     				returnVector.addAll(Arrays.asList(sched.getJobNames(groupName)));
+    			}
     		} catch (SchedulerException se) {
     			throw new ServiceException("SchedulerService.getJobNames - Could not get job names for group: "
     					+ groupName + " : " + se.getMessage());
+    		}
     		return returnVector;
+    	}
     	private void scheduleSecondlyJob(String name, Class<Job> jobClass, Calendar startTime, int interval, String jobGroup) throws ServiceException {
     		JobDetail jobDetail = new JobDetail(name, jobGroup, jobClass);
     		Trigger trigger = TriggerUtils.makeSecondlyTrigger(interval);
     		trigger.setName(name);
     		trigger.setStartTime(startTime.getTime());
     		try {
     			sched.scheduleJob(jobDetail, trigger);
     		} catch (SchedulerException se) {
     			throw new ServiceException("SchedulerService.scheduleSecondlyJob - Could not create "
     					+ "scheduler: " + se.getMessage());
+    		}
+    	}
     	private void scheduleMinutelyJob(String name, Class<Job> jobClass, Calendar startTime, int interval, String jobGroup) throws ServiceException {
     		JobDetail jobDetail = new JobDetail(name, jobGroup, jobClass);
     		Trigger trigger = TriggerUtils.makeMinutelyTrigger(interval);
     		trigger.setName(name);
     		trigger.setStartTime(startTime.getTime());
     		try {
     			sched.scheduleJob(jobDetail, trigger);
     		} catch (SchedulerException se) {
     			throw new ServiceException("SchedulerService.scheduleMinutelyJob - Could not create "
     					+ "scheduler: " + se.getMessage());
+    		}
+    	}
     	private void scheduleHourlyJob(String name, Class<Job> jobClass, Calendar startTime, int interval, String jobGroup) throws ServiceException {
     		JobDetail jobDetail = new JobDetail(name, jobGroup, jobClass);
     		Trigger trigger = TriggerUtils.makeHourlyTrigger(interval);
     		trigger.setName(name);
     		trigger.setStartTime(startTime.getTime());
     		try {
     			sched.scheduleJob(jobDetail, trigger);
     		} catch (SchedulerException se) {
     			throw new ServiceException("SchedulerService.scheduleHourlyJob - Could not create "
     					+  "scheduler: " + se.getMessage());
+    		}
+    	}
     	private void scheduleDailyJob(String name, Class<Job> jobClass, Calendar startTime, int interval, String jobGroup) throws ServiceException {
     		JobDetail jobDetail = new JobDetail(name, jobGroup, jobClass);
     		Trigger trigger = TriggerUtils.makeHourlyTrigger(interval * 24);
     		trigger.setName(name);
     		trigger.setStartTime(startTime.getTime());
     		try {
     			sched.scheduleJob(jobDetail, trigger);
     		} catch (SchedulerException se) {
     			throw new ServiceException("SchedulerService.scheduleHourlyJob - Could not create "
     					+ "scheduler: " + se.getMessage());
+    		}
+    	}
     	private Calendar getStartDateFromDelay(String delay) throws ServiceException {
     		Calendar cal = Calendar.getInstance();
     		char delayUnit = delay.trim().charAt(delay.length());
     		String delayStrValue = delay.trim().substring(0, delay.length() - 1);
     		int delayValue;
     		try {
     			delayValue = Integer.parseInt(delayStrValue);
     		} catch (NumberFormatException nfe) {
     			throw new ServiceException("SchedulerService.getStartDateFromDelay - Could not "
     					+ "parse delay value into an integer: " + delayStrValue);
+    		}
     		switch (delayUnit) {
     		case 's':
     		case 'S':
     			cal.add(Calendar.SECOND, delayValue);
     			break;
     		case 'm':
     		case 'M':
     			cal.add(Calendar.MINUTE, delayValue);
     			break;
     		case 'h':
     		case 'H':
     			cal.add(Calendar.HOUR, delayValue);
     			break;
     		case 'd':
     		case 'D':
     			cal.add(Calendar.DAY_OF_YEAR, delayValue);
     			break;
     		default:
     			throw new ServiceException("SchedulerService.getStartDateFromDelay - Could not "
     					+ "interpret delay unit: " + delayUnit + ". Unit must be s, m, h or d");
+    		}
     		return cal;
+    	}
+    }

     /**
      *  '$RCSfile$'
      *    Purpose: A Class that manages database access of scheduled task
      *             information.
      *  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-23 13:56:56 -0800 (Mon, 23 Mar 2009) $'
      * '$Revision: 4854 $'
+     *
      * 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.sql.PreparedStatement;
     import java.sql.SQLException;
     import java.util.Enumeration;
     import java.util.Hashtable;
     import org.apache.log4j.Logger;
     import edu.ucsb.nceas.shared.AccessException;
     import edu.ucsb.nceas.shared.BaseAccess;
     public class ScheduledJobParamsAccess extends BaseAccess {
     	private Logger logMetacat = Logger.getLogger(ScheduledJobParamsAccess.class);
     	public ScheduledJobParamsAccess() throws AccessException {
     		super("ScheduledJobParamsAccess");
+    	}
     	protected void createJobParams(Long jobId, Hashtable<String, String> jobParams) throws AccessException {
     		Enumeration<String> paramKeys = jobParams.keys();
     		while(paramKeys.hasMoreElements()) {
     			String paramKey = paramKeys.nextElement();
     			ScheduledJobParamsDAO jobParamsDAO = new ScheduledJobParamsDAO();
     			jobParamsDAO.setStatus(ScheduledJobInterface.STATE_SCHEDULED);
     			jobParamsDAO.setJobId(jobId);
     			jobParamsDAO.setKey(paramKey);
     			jobParamsDAO.setValue(jobParams.get(paramKey));
     			try {
     				String sql =
     					"INSERT INTO scheduled_job_params (date_created, date_updated, status, job_id, key, value) "
     					+ "VALUES(now(), now(), ?, ?, ?, ?)";
     				PreparedStatement pstmt = conn.prepareStatement(sql);
     				pstmt.setString(1, jobParamsDAO.getStatus());
     				pstmt.setLong(2, jobParamsDAO.getJobId());
     				pstmt.setString(3, jobParamsDAO.getKey());
     				pstmt.setString(4, jobParamsDAO.getValue());
     				logMetacat.info("SQL createJobParams - " + sql);
     				logMetacat.info("SQL params:  [" + jobParamsDAO.getStatus() + ","
     						+ jobParamsDAO.getJobId() + ","
     						+ jobParamsDAO.getKey() + ","
     						+ jobParamsDAO.getValue().toString() + "]");
     				pstmt.execute();
     			} catch (SQLException sqle) {
     				// Just throw the exception.  The ScheduledJobAccess class should handle cleanup.
     				throw new AccessException("ScheduledJobParamsAccess.createJobParams - SQL error when creating scheduled job parameter : "
     					 + sqle.getMessage());
+    			}
+    		}
+    	}
     	protected void deleteJobParams(Long jobId) throws AccessException {
     		try {
     			String sql = "UPDATE scheduled_job_params SET status = ? WHERE jobId = ?";
     			pstmt.setString(1, ScheduledJobInterface.STATE_DELETED);
     			pstmt.setLong(1, jobId);
     			logMetacat.info("SQL deleteJobParams - " + sql);
     			pstmt.execute();
     		} catch (SQLException sqle) {
     			throw new AccessException("ScheduledJobParamsAccess.deleteJobParams - SQL error "
     					+ "when deleting scheduled job params for job" + jobId  + " : "  + sqle.getMessage());
+    		}
+    	}
+    }

     /**
      *  '$RCSfile$'
      *    Purpose: A Class that holds the data from the scheduled_task
      *             table in the database.
      *  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-23 13:56:56 -0800 (Mon, 23 Mar 2009) $'
      * '$Revision: 4854 $'
+     *
      * 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 edu.ucsb.nceas.shared.BaseDAO;
     public class ScheduledJobParamsDAO extends BaseDAO {
     	private Long _jobId;
     	private String _key;
     	private String _value;
     	public Long getJobId() {
     		return _jobId;
+    	}
     	public void setJobId(Long jobId) {
     		_jobId = jobId;
+    	}
     	public String getKey() {
     		return _key;
+    	}
     	public void setKey(String key) {
     		_key = key;
+    	}
     	public String getValue() {
     		return _value;
+    	}
     	public void setValue(String value) {
     		_value = value;
+    	}
+    }

     /**
      *  '$RCSfile$'
      *    Purpose: A Class that runs a single scheduled report task
      *  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-23 13:56:56 -0800 (Mon, 23 Mar 2009) $'
      * '$Revision: 4854 $'
+     *
      * 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 org.quartz.InterruptableJob;
     public interface ScheduledJobInterface extends InterruptableJob {
     	public static String STATE_SCHEDULED = "scheduled";
     	public static String STATE_EXECUTING = "executing";
     	public static String STATE_UNSHCEDULED = "unscheduled";
     	public static String STATE_DELETED = "deleted";
+    }

Project

General

Profile

Metacat

Revision 4951

Added by daigle over 15 years ago