/ - Diff - Metacat - Ecoinformatics Redmine

« Previous | Next »

Revision 5030

Added by daigle over 15 years ago

Change location of PropertyService to properties directory

     /**
      *  '$RCSfile$'
      *    Purpose: A Class that implements properties methods for metacat
      *  Copyright: 2008 Regents of the University of California and the
      *             National Center for Ecological Analysis and Synthesis
      *    Authors: Michael Daigle
+     *
      *   '$Author$'
      *     '$Date$'
      * '$Revision$'
+     *
      * 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.service;
     import java.io.IOException;
     import java.util.Map;
     import java.util.Set;
     import java.util.Vector;
     import javax.servlet.ServletContext;
     import javax.servlet.http.HttpServletRequest;
     import javax.xml.transform.TransformerException;
     import org.apache.log4j.Logger;
     import edu.ucsb.nceas.metacat.shared.BaseService;
     import edu.ucsb.nceas.metacat.shared.MetacatUtilException;
     import edu.ucsb.nceas.metacat.shared.ServiceException;
     import edu.ucsb.nceas.metacat.util.SystemUtil;
     import edu.ucsb.nceas.utilities.FileUtil;
     import edu.ucsb.nceas.utilities.GeneralPropertyException;
     import edu.ucsb.nceas.utilities.MetaDataProperty;
     import edu.ucsb.nceas.utilities.PropertiesMetaData;
     import edu.ucsb.nceas.utilities.PropertyNotFoundException;
     import edu.ucsb.nceas.utilities.SortedProperties;
     /**
      * A suite of utility classes for the metadata configuration utility
      */
     public class PropertyService extends BaseService {
     	private static PropertyService propertyService = null;
     	// system is configured
     	public static final String CONFIGURED = "true";
     	// system has never been configured
     	public static final String UNCONFIGURED = "false";
     	public static final String BYPASSED = "bypassed";
     	private static String MAIN_CONFIG_NAME = "";
     	private static final String AUTH_CONFIG_NAME = "auth.properties";
     	private static boolean bypassAlreadyChecked = false;
     	private static String recommendedExternalDir = null;
     	private static String mainPropertiesFilePath = null;
     	private static SortedProperties mainProperties = null;
     	private static String mainBackupPropertiesFilePath = null;
     	private static SortedProperties mainBackupProperties = null;
     	private static String propertiesMetaDataFilePath = null;
     	private static PropertiesMetaData mainMetaData = null;
     	private static String authBackupPropertiesFilePath = null;
     	private static SortedProperties authBackupProperties = null;
     	private static String authMetaDataFilePath = null;
     	private static PropertiesMetaData authMetaData = null;
     	private static boolean testInstance = false;
     	private static String testConfigDir = null;
     	private static Logger logMetacat = Logger.getLogger(PropertyService.class);
     	/**
     	 * private constructor since this is a singleton
+    	 *
     	 * @param servletContext the context we will use to get relative paths
     	 */
     	private PropertyService() throws ServiceException {
     		_serviceName = "PropertyService";
     		MAIN_CONFIG_NAME = ServiceService.CONFIG_FILE_NAME;
     		initialize();
+    	}
     	/**
     	 * Get the single instance of PropertyService.
+    	 *
     	 * @return the single instance of PropertyService
     	 */
     	public static PropertyService getInstance() throws ServiceException {
     		if (propertyService == null) {
     			propertyService = new PropertyService();
+    		}
     		return propertyService;
+    	}
     	/**
     	 * Get the single instance of PropertyService for test purposes.  In this
     	 * case, we allow the configuration directory to be passed in.
+    	 *
     	 * @param configDir the configuration directory we need to look in
     	 * @return the single instance of PropertyService
     	 */
     	public static PropertyService getTestInstance(String configDir) throws ServiceException {
     		if (propertyService == null) {
     			testInstance = true;
     			testConfigDir = configDir;
     			propertyService = new PropertyService();
+    		}
     		return propertyService;
+    	}
     	public boolean refreshable() {
     		return true;
+    	}
     	public void doRefresh() throws ServiceException {
     		initialize();
+    	}
     	public void stop() throws ServiceException {
     		return;
+    	}
     	/**
     	 * Initialize the singleton.
+    	 *
     	 * @param servletContext the context we will use to get relative paths
     	 */
     	private void initialize() throws ServiceException {
     		logMetacat.debug("Initializing PropertyService");
     		String configDir;
     		if (testInstance) {
     			configDir = testConfigDir;
     		} else {
     			configDir = ServiceService.getRealConfigDir();
+    		}
     		try {
     			// mainProperties will hold the primary configuration values for
     			// metacat.
     			mainPropertiesFilePath = configDir + FileUtil.getFS() + MAIN_CONFIG_NAME;
     			mainProperties = new SortedProperties(mainPropertiesFilePath);
     			mainProperties.load();
     			// mainMetaData holds configuration information about main
     			// properties. This is primarily used to display input fields on
     			// the configuration page. The information is retrieved from an
     			// xml metadata file
     			propertiesMetaDataFilePath =
     				configDir + FileUtil.getFS() + MAIN_CONFIG_NAME + ".metadata.xml";
     			mainMetaData = new PropertiesMetaData(propertiesMetaDataFilePath);
     			// authMetaData holds configuration information about organization
     			// level
     			// properties. This is primarily used to display input fields on
     			// the auth configuration page. The information is retrieved
     			// from an xml metadata file dedicated just to auth properties.
     			authMetaDataFilePath =
     				configDir + FileUtil.getFS() + AUTH_CONFIG_NAME + ".metadata.xml";
     			authMetaData = new PropertiesMetaData(authMetaDataFilePath);
     			String recommendedExternalDir = SystemUtil.discoverExternalDir();
     			setRecommendedExternalDir(recommendedExternalDir);
     			String backupPath = getProperty("application.backupDir");
     			if (backupPath == null || backupPath.equals("")) {
     				backupPath = SystemUtil.getStoredBackupDir();
+    			}
     			if (backupPath == null || backupPath.equals("") && recommendedExternalDir != null) {
     				backupPath =
     					recommendedExternalDir + FileUtil.getFS() + "." + ServiceService.getRealApplicationContext();
+    			}
     			// if backupPath is still null, no reason to initialize the
     			// backup properties. The system will need to prompt the user for
     			// the backup properties and reinitialize PropertyService.
     			if (backupPath != null && !backupPath.equals("")) {
     				setProperty("application.backupDir", backupPath);
     				SystemUtil.writeStoredBackupFile(backupPath);
     				// The mainBackupProperties hold properties that were backed up
     				// the last time the application was configured. On disk, the
     				// file will look like a smaller version of metacat.properties.
     				// It is stored in the data storage directory outside the
     				// application directories.
     				mainBackupPropertiesFilePath =
     					backupPath + FileUtil.getFS() + MAIN_CONFIG_NAME + ".backup";
     				mainBackupProperties = new SortedProperties(mainBackupPropertiesFilePath);
     				mainBackupProperties.load();
     				// The authBackupProperties hold properties that were backed up
     				// the last time the auth was configured. On disk, the file
     				// will look like a smaller version of metacat.properties. It
     				// is stored in the data storage directory outside the
     				// application directories.
     				authBackupPropertiesFilePath =
     					backupPath + FileUtil.getFS() + AUTH_CONFIG_NAME + ".backup";
     				authBackupProperties = new SortedProperties(authBackupPropertiesFilePath);
     				authBackupProperties.load();
+    			}
     		} catch (TransformerException te) {
     			throw new ServiceException("Transform problem while loading properties: "
     					+ te.getMessage());
     		} catch (IOException ioe) {
     			throw new ServiceException("I/O problem while loading properties: "
     					+ ioe.getMessage());
     		} catch (GeneralPropertyException gpe) {
     			throw new ServiceException("General properties problem while loading properties: "
     					+ gpe.getMessage());
     		} catch (MetacatUtilException ue) {
     			throw new ServiceException("Utilities problem while loading properties: "
     					+ ue.getMessage());
+    		}
+    	}
     	/**
     	 * Utility method to get a property value from the properties file
+    	 *
     	 * @param propertyName
     	 *            the name of the property requested
     	 * @return the String value for the property
     	 */
     	public static String getProperty(String propertyName)
     			throws PropertyNotFoundException {
     		return mainProperties.getProperty(propertyName);
+    	}
     	/**
          * Get a set of all property names.
+         *
          * @return Set of property names
          */
         public static Vector<String> getPropertyNames() {
         	return mainProperties.getPropertyNames();
+        }
     	/**
     	 * Get a Set of all property names that start with the groupName prefix.
+    	 *
     	 * @param groupName
     	 *            the prefix of the keys to search for.
     	 * @return enumeration of property names
     	 */
         public static Vector<String> getPropertyNamesByGroup(String groupName) {
         	return mainProperties.getPropertyNamesByGroup(groupName);
+        }
     	/**
     	 * Get a Map of all properties that start with the groupName prefix.
+    	 *
     	 * @param groupName
     	 *            the prefix of the keys to search for.
     	 * @return Map of property names
     	 */
         public static Map<String, String> getPropertiesByGroup(String groupName) throws PropertyNotFoundException {
         	return mainProperties.getPropertiesByGroup(groupName);
+        }
     	/**
     	 * Utility method to set a property value both in memory and to the
     	 * properties file
+    	 *
     	 * @param propertyName
     	 *            the name of the property requested
     	 * @param newValue
     	 *            the new value for the property
     	 */
     	public static void setProperty(String propertyName, String newValue) throws GeneralPropertyException {
     			mainProperties.setProperty(propertyName, newValue);
     			mainProperties.store();
+    	}
     	/**
     	 * Utility method to set a property value in memory. This will NOT cause the
     	 * property to be written to disk. Use this method to set multiple
     	 * properties in a row without causing excessive I/O. You must call
     	 * persistProperties() once you're done setting properties to have them
     	 * written to disk.
+    	 *
     	 * @param propertyName
     	 *            the name of the property requested
     	 * @param newValue
     	 *            the new value for the property
     	 */
     	public static void setPropertyNoPersist(String propertyName, String newValue) throws GeneralPropertyException {
     		mainProperties.setPropertyNoPersist(propertyName, newValue);
+    	}
     	/**
     	 * Save the properties to a properties file. Note, the
     	 * order and comments will be preserved.
     	 */
     	public static void persistProperties() throws GeneralPropertyException {
     		mainProperties.store();
+    	}
     	/**
     	 * Get the main backup properties file. These are configurable properties that
     	 * are stored outside the metacat install directories so the user does not
     	 * need to re-enter all the configuration information every time they do an
     	 * upgrade.
+    	 *
     	 * @return a SortedProperties object with the backup properties
     	 */
     	public static SortedProperties getMainBackupProperties() {
     		return mainBackupProperties;
+    	}
     	/**
     	 * Get the auth backup properties file. These are configurable
     	 * properties that are stored outside the metacat install directories so
     	 * the user does not need to re-enter all the configuration information
     	 * every time they do an upgrade.
+    	 *
     	 * @return a SortedProperties object with the backup properties
     	 */
     	public static SortedProperties getAuthBackupProperties() {
     		return authBackupProperties;
+    	}
     	/**
     	 * Get the main properties metadata. This is retrieved from an xml file that
     	 * describes the attributes of configurable properties.
+    	 *
     	 * @return a PropertiesMetaData object with the main properties metadata
     	 */
     	public static PropertiesMetaData getMainMetaData() {
     		return mainMetaData;
+    	}
     	/**
     	 * Get the auth properties metadata. This is retrieved from an xml
     	 * file that describes the attributes of configurable properties.
+    	 *
     	 * @return a PropertiesMetaData object with the organization properties
     	 *         metadata
     	 */
     	public static PropertiesMetaData getAuthMetaData() {
     		return authMetaData;
+    	}
     	/**
     	 * Writes out backup configurable properties to a file.
     	 */
     	public static void persistMainBackupProperties()
     			throws GeneralPropertyException {
     		// Use the metadata to extract configurable properties from the
     		// overall properties list, and store those properties.
     		try {
     			SortedProperties backupProperties = new SortedProperties(mainBackupPropertiesFilePath);
     			// Populate the backup properties for main metacat properties using
     			// the associated metadata file
     			PropertiesMetaData mainMetadata = new PropertiesMetaData(propertiesMetaDataFilePath);
     			Map<String, MetaDataProperty> mainKeyMap = mainMetadata.getProperties();
     			Set<String> mainKeySet = mainKeyMap.keySet();
     			for (String propertyKey : mainKeySet) {
     				// don't backup passwords
     				MetaDataProperty metaData = mainKeyMap.get(propertyKey);
     				if (!metaData.getFieldType().equals(MetaDataProperty.PASSWORD_TYPE)) {
     					backupProperties.addProperty(propertyKey, getProperty(propertyKey));
+    				}
+    			}
     			// store the properties to file
     			backupProperties.store();
     			mainBackupProperties =
     				new SortedProperties(mainBackupPropertiesFilePath);
     			mainBackupProperties.load();
     		} catch (TransformerException te) {
     			throw new GeneralPropertyException("Could not transform backup properties xml: "
     					+ te.getMessage());
     		} catch (IOException ioe) {
     			throw new GeneralPropertyException("Could not backup configurable properties: "
     					+ ioe.getMessage());
+    		}
+    	}
     	/**
     	 * Writes out backup configurable properties to a file.
     	 */
     	public static void persistAuthBackupProperties(ServletContext servletContext)
     			throws GeneralPropertyException {
     		// Use the metadata to extract configurable properties from the
     		// overall properties list, and store those properties.
     		try {
     			SortedProperties backupProperties =
     				new SortedProperties(authBackupPropertiesFilePath);
     			// Populate the backup properties for auth properties using
     			// the associated metadata file
     			PropertiesMetaData authMetadata = new PropertiesMetaData(authMetaDataFilePath);
     			Map<String, MetaDataProperty> authKeyMap = authMetadata.getProperties();
     			Set<String> authKeySet = authKeyMap.keySet();
     			for (String propertyKey : authKeySet) {
     				// don't backup passwords
     				MetaDataProperty metaData = authKeyMap.get(propertyKey);
     				if (!metaData.getFieldType().equals(MetaDataProperty.PASSWORD_TYPE)) {
     					backupProperties.addProperty(propertyKey, getProperty(propertyKey));
+    				}
+    			}
     			// store the properties to file
     			backupProperties.store();
     			authBackupProperties =
     				new SortedProperties(authBackupPropertiesFilePath);
     			authBackupProperties.load();
     		} catch (TransformerException te) {
     			throw new GeneralPropertyException("Could not transform backup properties xml: "
     					+ te.getMessage());
     		} catch (IOException ioe) {
     			throw new GeneralPropertyException("Could not backup configurable properties: "
     					+ ioe.getMessage());
+    		}
+    	}
     	/**
     	 * Reports whether properties are fully configured.
+    	 *
     	 * @return a boolean that is true if properties are not unconfigured and
     	 *         false otherwise
     	 */
     	public static boolean arePropertiesConfigured() throws MetacatUtilException {
     		try {
     			String propertiesConfigured = PropertyService.getProperty("configutil.propertiesConfigured");
     			if (propertiesConfigured != null && !propertiesConfigured.equals(UNCONFIGURED)) {
     				return true;
+    			}
     			return false;
     		} catch (PropertyNotFoundException pnfe) {
     			throw new MetacatUtilException("Could not determine if properties are configured: "
     					+ pnfe.getMessage());
+    		}
+    	}
     	/**
     	 * Determine if the system is configured to bypass configuration. If so, the
     	 * system will look for backup configuration files at startup time and use
     	 * those to configure metacat. The bypass options should only be set by
     	 * developers. Production code should never bypass confguration.
+    	 *
     	 * @return true if dev.runConfiguration is set to true in metacat.properties
     	 *         and we have not already checked for bypass, false otherwise.
     	 */
     	public static boolean doBypass() throws PropertyNotFoundException {
     		// We only want to go through the check once to see if we want to
     		// bypass the configuration.  We don't want to run through all of
     		// this every time  we hit metacat.
     		if (bypassAlreadyChecked) {
     			logMetacat.debug("bypassConfiguration not performing full bypass check.  Bypass set to false");
     			return false;
+    		}
     		// check how dev.runConfiguration is set in metacat.properties
     		String strRunConfiguration = PropertyService.getProperty("dev.runConfiguration");
     		boolean runConfiguration = Boolean.parseBoolean(strRunConfiguration);
     		logMetacat.debug("bypassConfiguration: dev.runConfiguration property set to: " + strRunConfiguration);
     		// if the dev.runConfiguration is true, return false here.
     		if (runConfiguration) {
     			bypassAlreadyChecked = true;
     			return false;
+    		}
     		return true;
+    	}
     	/**
     	 * Reports whether the metacat configuration utility should be run.
     	 * Returns false if
     	 *   -- dev.runConfiguration=false and
     	 *   -- backup properties file exists
     	 * Note that dev.runConfiguration should only be set to false when
     	 * reinstalling the same version of the application in developement.
+    	 *
     	 * @return a boolean that is false if dev.runConfiguration is false and
     	 * the backup properties file exists.
     	 */
     	public static void bypassConfiguration() throws ServiceException {
     		try {
     			boolean doBypass = doBypass();
     			if (!doBypass) {
     				throw new ServiceException(
     						"Attempting to do bypass when system is not configured for it.");
+    			}
     			// The system is bypassing the configuration utility. We need to
     			// get the backup properties and replace existing properties with
     			// backup values.  We do this for main and org properties.
     			logMetacat.debug("bypassConfiguration: setting main backup properties.");
     			SortedProperties mainBackupProperties = getMainBackupProperties();
     			Vector<String> backupPropertyNames =
     				mainBackupProperties.getPropertyNames();
     			for (String backupPropertyName : backupPropertyNames) {
     				String value = mainBackupProperties.getProperty(backupPropertyName);
     				setPropertyNoPersist(backupPropertyName, value);
+    			}
     			logMetacat.debug("bypassConfiguration: setting auth backup properties.");
     			SortedProperties authBackupProperties = getAuthBackupProperties();
     			Vector<String> authBackupPropertyNames =
     				authBackupProperties.getPropertyNames();
     			for (String authBackupPropertyName : authBackupPropertyNames) {
     				String value = authBackupProperties.getProperty(authBackupPropertyName);
     				setPropertyNoPersist(authBackupPropertyName, value);
+    			}
     			logMetacat.debug("bypassConfiguration: setting configutil sections to true.");
     			setPropertyNoPersist("configutil.propertiesConfigured", "true");
     			setPropertyNoPersist("configutil.authConfigured", "true");
     			setPropertyNoPersist("configutil.skinsConfigured", "true");
     			setPropertyNoPersist("configutil.databaseConfigured", "true");
     			setPropertyNoPersist("configutil.geoserverConfigured", "bypassed");
     			persistProperties();
     		} catch (PropertyNotFoundException pnfe) {
     			logMetacat.error("bypassConfiguration: Could not find property: " + pnfe.getMessage());
     		} catch (GeneralPropertyException gpe) {
     			logMetacat.error("bypassConfiguration: General property error: " + gpe.getMessage());
+    		}
     		bypassAlreadyChecked = true;
+    	}
     	/**
     	 * Take input from the user in an HTTP request about an property to be changed
     	 * and update the metacat property file with that new value if it has
     	 * changed from the value that was originally set.
+    	 *
     	 * @param request
     	 *            that was generated by the user
     	 * @param response
     	 *            to send output back to the user
     	 * @param propertyName
     	 *            the name of the property to be checked and set
     	 */
     	public static void checkAndSetProperty(HttpServletRequest request, String propertyName)
     			throws GeneralPropertyException {
     		String value = PropertyService.getProperty(propertyName);
     		String newValue = request.getParameter(propertyName);
     		if (newValue != null && !newValue.trim().equals(value)) {
     			PropertyService.setPropertyNoPersist(propertyName, newValue.trim());
+    		}
+    	}
     	/**
     	 * Sets the recommended external directory.  This is populated during initialization
     	 * time using the SystemUtil.discoverExternalDir() method.  This directory will be used to
     	 * suggest external user directories when the user configures metacat for the first time.
+    	 *
     	 */
     	public static void setRecommendedExternalDir(String extBaseDir) {
     		recommendedExternalDir = extBaseDir;
+    	}
     	/**
     	 * Returns the recommended external base directory.  This is populated during initialization
     	 * time using the SystemUtil.discoverExternalBaseDir() method.  This directory will be used to
     	 * suggest external user directories when the user configures metacat for the first time.
+    	 *
     	 * @return a String holding the recommended external directory
     	 */
     	public static String getRecommendedExternalDir() {
     		return recommendedExternalDir;
+    	}
+    }

     /**
      *  '$RCSfile$'
      *    Purpose: A Class that implements properties methods for metacat
      *             skins
      *  Copyright: 2008 Regents of the University of California and the
      *             National Center for Ecological Analysis and Synthesis
      *    Authors: Michael Daigle
+     *
      *   '$Author$'
      *     '$Date$'
      * '$Revision$'
+     *
      * 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.service;
     import java.io.IOException;
     import java.util.HashMap;
     import java.util.Map;
     import java.util.Set;
     import java.util.Vector;
     import javax.servlet.http.HttpServletRequest;
     import javax.xml.transform.TransformerException;
     import org.apache.log4j.Logger;
     import edu.ucsb.nceas.metacat.shared.BaseService;
     import edu.ucsb.nceas.metacat.shared.MetacatUtilException;
     import edu.ucsb.nceas.metacat.shared.ServiceException;
     import edu.ucsb.nceas.metacat.util.SkinUtil;
     import edu.ucsb.nceas.utilities.FileUtil;
     import edu.ucsb.nceas.utilities.GeneralPropertyException;
     import edu.ucsb.nceas.utilities.MetaDataProperty;
     import edu.ucsb.nceas.utilities.PropertiesMetaData;
     import edu.ucsb.nceas.utilities.PropertyNotFoundException;
     import edu.ucsb.nceas.utilities.SortedProperties;
     /**
      * A suite of utility classes for the skin configuration utility
      */
     public class SkinPropertyService extends BaseService {
     	private static SkinPropertyService skinService = null;
     	private static boolean bypassAlreadyChecked = false;
     	private static String BACKUP_DIR = null;
     	private static Vector<String> skinNames = null;
     	private static HashMap<String, SortedProperties> skinPropertiesMap = null;
     	private static HashMap<String, SortedProperties> skinBackupPropertiesMap = null;
     	private static HashMap<String, PropertiesMetaData> skinMetaDataMap = null;
     	private static Logger logMetacat = Logger.getLogger(SkinPropertyService.class);
     	/**
     	 * private constructor since this is a singleton
+    	 *
     	 * @param servletContext
     	 *            the context we will use to get relative paths
     	 */
     	private SkinPropertyService() throws ServiceException {
     		try {
     			_serviceName = "SkinPropertyService";
     			initialize();
     		} catch (GeneralPropertyException gpe) {
     			throw new ServiceException(
     					"Properties problem while initializing SkinPropertyService: "
     							+ gpe.getMessage());
     		} catch (IOException ioe) {
     			throw new ServiceException("I/O Problem while initializing SkinPropertyService: "
     					+ ioe.getMessage());
+    		}
+    	}
     	/**
     	 * Get the single instance of SkinPropertyService.
+    	 *
     	 * @param servletContext
     	 *            the context we will use to get relative paths
     	 * @return the single instance of SkinPropertyService
     	 */
     	public static SkinPropertyService getInstance() throws ServiceException {
     		if (skinService == null) {
     			skinService = new SkinPropertyService();
+    		}
     		return skinService;
+    	}
     	public boolean refreshable() {
     		return true;
+    	}
     	public void doRefresh() throws ServiceException {
     		try {
     			initialize();
     		} catch (IOException ioe) {
     			throw new ServiceException("Could not refresh SkinPropertyService due to"
     					+ " I/O error: " + ioe.getMessage());
     		} catch (GeneralPropertyException gpe) {
     			throw new ServiceException("Could not refresh SkinPropertyService due to"
     					+ " property error: " + gpe.getMessage());
+    		}
+    	}
     	public void stop() throws ServiceException {
     		return;
+    	}
     	/**
     	 * Initialize the singleton.
+    	 *
     	 * @param servletContext
     	 *            the context we will use to get relative paths
     	 */
     	private void initialize() throws IOException, GeneralPropertyException,
     			ServiceException {
     		logMetacat.debug("Initializing SkinService");
     		BACKUP_DIR = PropertyService.getProperty("application.backupDir");
     		skinNames = SkinUtil.getSkinNames();
     		skinPropertiesMap = new HashMap<String, SortedProperties>();
     		skinBackupPropertiesMap = new HashMap<String, SortedProperties>();
     		skinMetaDataMap = new HashMap<String, PropertiesMetaData>();
     		try {
     			for (String skinName : skinNames) {
     				String propertyFilePath = ServiceService.getRealSkinDir()
     						+ FileUtil.getFS() + skinName + FileUtil.getFS() + skinName
     						+ ".properties";
     				if (FileUtil.getFileStatus(propertyFilePath) < FileUtil.EXISTS_READ_WRITABLE) {
     					logMetacat.error("Skin property file: " + propertyFilePath
     							+ " does not exist read/writable. This skin will not be available.");
     					continue;
+    				}
     				SortedProperties skinProperties = new SortedProperties(propertyFilePath);
     				skinProperties.load();
     				skinPropertiesMap.put(skinName, skinProperties);
     				String metaDataFilePath = ServiceService.getRealSkinDir()
     						+ FileUtil.getFS() + skinName + FileUtil.getFS() + skinName
     						+ ".properties.metadata.xml";
     				if (FileUtil.getFileStatus(metaDataFilePath) > FileUtil.DOES_NOT_EXIST) {
     					PropertiesMetaData skinMetaData = new PropertiesMetaData(metaDataFilePath);
     					skinMetaDataMap.put(skinName, skinMetaData);
     				} else {
     					skinPropertiesMap.remove(skinName);
     					logMetacat.error("Could not find skin property metadata file for skin: "
     							+ skinName + " at: " + metaDataFilePath
     							+ ". This skin will not be available.");
     					continue;
+    				}
     				String backupPropertyFilePath = BACKUP_DIR + FileUtil.getFS() + skinName
     						+ ".properties.backup";
     				if (FileUtil.getFileStatus(backupPropertyFilePath) > FileUtil.DOES_NOT_EXIST) {
     					SortedProperties skinBackupProperties = new SortedProperties(
     							backupPropertyFilePath);
     					skinBackupProperties.load();
     					skinBackupPropertiesMap.put(skinName, skinBackupProperties);
     				} else {
     					logMetacat.warn("Could not find backup properties for skin: "
     							+ skinName + " at: " + backupPropertyFilePath);
+    				}
+    			}
     		} catch (TransformerException te) {
     			throw new GeneralPropertyException(te.getMessage());
+    		}
+    	}
     	/**
     	 * Utility method to get a property value from the properties file for a
     	 * specific skin.
+    	 *
     	 * @param skinName
     	 *            the skin for which we want to retrieve the property
     	 * @param propertyName
     	 *            the name of the property requested
     	 * @return the String value for the property
     	 */
     	public static String getProperty(String skinName, String propertyName)
     			throws PropertyNotFoundException {
     		SortedProperties skinProperties = skinPropertiesMap.get(skinName);
     		if (skinProperties == null) {
     			throw new PropertyNotFoundException("There is not property map for "
     					+ skinName);
+    		}
     		return skinProperties.getProperty(propertyName);
+    	}
     	/**
     	 * Get a set of all property names for a given skin.
+    	 *
     	 * @param skinName
     	 *            the skin for which we want to retrieve the property names
     	 * @return Set of property names
     	 */
     	public static Vector<String> getPropertyNames(String skinName)
     			throws PropertyNotFoundException {
     		SortedProperties skinProperties = skinPropertiesMap.get(skinName);
     		if (skinProperties == null) {
     			throw new PropertyNotFoundException("There is not property map for "
     					+ skinName);
+    		}
     		return skinProperties.getPropertyNames();
+    	}
     	/**
     	 * Get a Set of all property names that start with the groupName prefix.
+    	 *
     	 * @param groupName
     	 *            the prefix of the keys to search for.
     	 * @return Vector of property names
     	 */
     	public static Vector<String> getPropertyNamesByGroup(String skinName, String groupName)
     			throws PropertyNotFoundException {
     		SortedProperties skinProperties = skinPropertiesMap.get(skinName);
     		if (skinProperties == null) {
     			throw new PropertyNotFoundException("There is not property map for "
     					+ skinName);
+    		}
     		return skinProperties.getPropertyNamesByGroup(groupName);
+    	}
     	/**
     	 * Get the main backup properties file. These are configurable properties
     	 * that are stored outside the metacat install directories so the user does
     	 * not need to re-enter all the configuration information every time they do
     	 * an upgrade.
+    	 *
     	 * @return a SortedProperties object with the backup properties
     	 */
     	public static HashMap<String, SortedProperties> getProperties() {
     		return skinPropertiesMap;
+    	}
     	/**
     	 * Get the main backup properties file. These are configurable properties
     	 * that are stored outside the metacat install directories so the user does
     	 * not need to re-enter all the configuration information every time they do
     	 * an upgrade.
+    	 *
     	 * @return a SortedProperties object with the backup properties
     	 */
     	public static SortedProperties getProperties(String skinName) {
     		return skinPropertiesMap.get(skinName);
+    	}
     	/**
     	 * Get the main backup properties file. These are configurable properties
     	 * that are stored outside the metacat install directories so the user does
     	 * not need to re-enter all the configuration information every time they do
     	 * an upgrade.
+    	 *
     	 * @return a SortedProperties object with the backup properties
     	 */
     	public static HashMap<String, SortedProperties> getBackupProperties() {
     		return skinBackupPropertiesMap;
+    	}
     	/**
     	 * Get the main backup properties file. These are configurable properties
     	 * that are stored outside the metacat install directories so the user does
     	 * not need to re-enter all the configuration information every time they do
     	 * an upgrade.
+    	 *
     	 * @return a SortedProperties object with the backup properties
     	 */
     	public static SortedProperties getBackupProperties(String skinName) {
     		return skinBackupPropertiesMap.get(skinName);
+    	}
     	/**
     	 * Get the main properties metadata. This is retrieved from an xml file that
     	 * describes the attributes of configurable properties.
+    	 *
     	 * @return a PropertiesMetaData object with the main properties metadata
     	 */
     	public static HashMap<String, PropertiesMetaData> getMetaData() {
     		return skinMetaDataMap;
+    	}
     	/**
     	 * Get the main properties metadata. This is retrieved from an xml file that
     	 * describes the attributes of configurable properties.
+    	 *
     	 * @return a PropertiesMetaData object with the main properties metadata
     	 */
     	public static PropertiesMetaData getMetaData(String skinName) {
     		return skinMetaDataMap.get(skinName);
+    	}
     	/**
     	 * Utility method to set a property value both in memory and to the
     	 * properties file
+    	 *
     	 * @param propertyName
     	 *            the name of the property requested
     	 * @param newValue
     	 *            the new value for the property
     	 */
     	public static void setProperty(String skinName, String propertyName, String newValue)
     			throws IOException, GeneralPropertyException {
     		SortedProperties skinProperties = skinPropertiesMap.get(skinName);
     		if (skinProperties == null) {
     			throw new GeneralPropertyException("There is not property map for "
     					+ skinName);
+    		}
     		skinProperties.setProperty(propertyName, newValue);
     		skinProperties.store();
+    	}
     	/**
     	 * Utility method to set a property value in memory. This will NOT cause the
     	 * property to be written to disk. Use this method to set multiple
     	 * properties in a row without causing excessive I/O. You must call
     	 * persistProperties() once you're done setting properties to have them
     	 * written to disk.
+    	 *
     	 * @param propertyName
     	 *            the name of the property requested
     	 * @param newValue
     	 *            the new value for the property
     	 */
     	public static void setPropertyNoPersist(String skinName, String propertyName,
     			String newValue) throws GeneralPropertyException {
     		SortedProperties skinProperties = skinPropertiesMap.get(skinName);
     		if (skinProperties == null) {
     			throw new GeneralPropertyException("There is not property map for "
     					+ skinName);
+    		}
     		skinProperties.setPropertyNoPersist(propertyName, newValue);
+    	}
     	/**
     	 * Save the properties to a properties file. Note, the order and comments
     	 * will be preserved.
     	 */
     	public static void persistProperties(String skinName) throws IOException,
     			GeneralPropertyException {
     		SortedProperties skinProperties = skinPropertiesMap.get(skinName);
     		if (skinProperties == null) {
     			throw new GeneralPropertyException("There is not property map for "
     					+ skinName);
+    		}
     		skinProperties.store();
+    	}
     	/**
     	 * Save the properties to a properties file. Note, the order and comments
     	 * will be preserved.
     	 */
     	public static void persistAllProperties() throws IOException,
     			GeneralPropertyException {
     		for (String skinName : skinNames) {
     			persistProperties(skinName);
+    		}
+    	}
     	/**
     	 * Writes out backup configurable properties to a file.
     	 */
     	public static void persistBackupProperties(String skinName)
     			throws GeneralPropertyException {
     		try {
     			String metaDataFilePath = ServiceService.getRealSkinDir() + FileUtil.getFS()
     					+ skinName + FileUtil.getFS() + skinName + ".properties.metadata.xml";
     			String backupPropertyFilePath = BACKUP_DIR + FileUtil.getFS() + skinName
     					+ ".properties.backup";
     			// Use the metadata to extract configurable properties from the
     			// overall properties list, and store those properties.
     			SortedProperties backupProperties = new SortedProperties(
     					backupPropertyFilePath);
     			// Populate the backup properties for main metacat properties using
     			// the associated metadata file
     			PropertiesMetaData skinMetadata = new PropertiesMetaData(metaDataFilePath);
     			Map<String, MetaDataProperty> skinKeyMap = skinMetadata.getProperties();
     			Set<String> skinKeySet = skinKeyMap.keySet();
     			for (String propertyKey : skinKeySet) {
     				// don't backup passwords
     				MetaDataProperty metaData = skinKeyMap.get(propertyKey);
     				if (!metaData.getFieldType().equals(MetaDataProperty.PASSWORD_TYPE)) {
     					backupProperties.addProperty(propertyKey, getProperty(skinName, propertyKey));
+    				}
+    			}
     			// store the properties to file
     			backupProperties.store();
     		} catch (TransformerException te) {
     			throw new GeneralPropertyException(
     					"Could not transform backup properties xml: " + te.getMessage());
     		} catch (IOException ioe) {
     			throw new GeneralPropertyException(
     					"Could not backup configurable properties: " + ioe.getMessage());
     		} catch (ServiceException se) {
     			throw new GeneralPropertyException("Could not get skins property file: "
     					+ se.getMessage());
+    		}
+    	}
     	/**
     	 * Reports whether properties are fully configured.
+    	 *
     	 * @return a boolean that is true if properties are not unconfigured and
     	 *         false otherwise
     	 */
     	public static boolean areSkinsConfigured() throws MetacatUtilException {
     		try {
     			return !PropertyService.getProperty("configutil.skinsConfigured").equals(
     					PropertyService.UNCONFIGURED);
     		} catch (PropertyNotFoundException pnfe) {
     			throw new MetacatUtilException("Could not determine if skins are configured: "
     					+ pnfe.getMessage());
+    		}
+    	}
     	/**
     	 * Take input from the user in an HTTP request about an property to be
     	 * changed and update the metacat property file with that new value if it
     	 * has changed from the value that was originally set.
+    	 *
     	 * @param request
     	 *            that was generated by the user
     	 * @param response
     	 *            to send output back to the user
     	 * @param propertyName
     	 *            the name of the property to be checked and set
     	 */
     	public static void checkAndSetProperty(HttpServletRequest request, String skinName,
     			String propertyName) throws GeneralPropertyException {
     		String newValue = request.getParameter(skinName + "." + propertyName);
     		checkAndSetProperty(newValue, skinName, propertyName);
+    	}
     	/**
     	 * Check user input against existing value and update the metacat property
     	 * file with that new value if it has changed from the value that was
     	 * originally set.
+    	 *
     	 * @param newValue
     	 *            the value that was returned by the form
     	 * @param skinname
     	 *            the skin that we are checking
     	 * @param propertyName
     	 *            the name of the property to be checked and set
     	 */
     	public static void checkAndSetProperty(String newValue, String skinName,
     			String propertyName) throws GeneralPropertyException {
     		String oldValue = SkinPropertyService.getProperty(skinName, propertyName);
     		if (newValue != null && !newValue.equals(oldValue)) {
     			SkinPropertyService.setPropertyNoPersist(skinName, propertyName, newValue);
+    		}
+    	}
     	/**
     	 * Reports whether the metacat configuration utility should be run. Returns
     	 * false if -- dev.runConfiguration=false and -- backup properties file
     	 * exists Note that dev.runConfiguration should only be set to false when
     	 * reinstalling the same version of the application in developement.
+    	 *
     	 * @return a boolean that is false if dev.runConfiguration is false and the
     	 *         backup properties file exists.
     	 */
     	public static boolean bypassConfiguration() {
     		boolean bypass = false;
     		// We only want to go through the check once to see if we want to
     		// bypass the configuration. We don't want to run through all of
     		// this every time we hit metacat.
     		if (bypassAlreadyChecked) {
     			return bypass;
+    		}
     		try {
     			// check how dev.runConfiguration is set in metacat.properties
     			String strRunConfiguration = PropertyService
     					.getProperty("dev.runConfiguration");
     			bypass = !(Boolean.parseBoolean(strRunConfiguration));
     			// if the deb.runConfiguration is true, return false here.
     			if (!bypass) {
     				bypassAlreadyChecked = true;
     				return false;
+    			}
     			// the system is bypassing the configuration utility. We need to
     			// get the backup properties and replace existing properties with
     			// backup values. We do this for main and org properties.
     			for (String skinName : skinNames) {
     				SortedProperties backupProperties = getBackupProperties(skinName);
     				Vector<String> backupPropertyNames = backupProperties.getPropertyNames();
     				for (String backupPropertyName : backupPropertyNames) {
     					String value = backupProperties.getProperty(backupPropertyName);
     					backupProperties.setPropertyNoPersist(backupPropertyName, value);
+    				}
     				backupProperties.store();
+    			}
     		} catch (PropertyNotFoundException pnfe) {
     			logMetacat.error("Could not find property: " + pnfe.getMessage());
     		} catch (GeneralPropertyException gpe) {
     			logMetacat.error("General property error: " + gpe.getMessage());
+    		}
     		bypassAlreadyChecked = true;
     		return bypass;
+    	}
+    }

     /**
      *  '$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.metacat.workflow;
     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.scheduler.SchedulerService;
     import edu.ucsb.nceas.metacat.service.PropertyService;
     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.metacat.workflow.WorkflowScheduler;
     /**
      * 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;
         /**
          * 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();
                 ServiceService serviceService = ServiceService.getInstance(context);
                 logMetacat.debug("ServiceService singleton created " + serviceService);
                 // Initialize the properties file
                 String dirPath = ServiceService.getRealConfigDir();
                 LOG_CONFIG_NAME = dirPath + "/log4j.properties";
                 PropertyConfigurator.configureAndWatch(LOG_CONFIG_NAME);
                 // Register preliminary services
                 ServiceService.registerService("PropertyService", PropertyService.getInstance());
                 ServiceService.registerService("SessionService", SessionService.getInstance());
                 ServiceService.registerService("SchedulerService", SchedulerService.getInstance());
         	} catch (ServiceException se) {
             	String errorMessage =
             		"Service problem while intializing WorkflowScheduler Servlet: " + se.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 e) {
     			logMetacat.error("Error in WorkflowSchedulerServlet.handleGetOrPost: "
     					+ e.getMessage());
     			e.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("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("The user is : " + userName);
+    			}
     			if (action.equals("refreshServices")) {
     				// TODO MCD this interface is for testing. It should go through
     				// a
     				// ServiceService class and only work for an admin user. Move to
     				// the

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff

Project

General

Profile

Metacat

Revision 5030

Added by daigle over 15 years ago