Metacat

/**

 *  '$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: daigle $'

 *     '$Date: 2008-07-11 10:08:07 -0700 (Fri, 11 Jul 2008) $'

 * '$Revision: 4107 $'

 *

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

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.util.LDAPUtil;

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

import edu.ucsb.nceas.utilities.FileUtil;

import edu.ucsb.nceas.utilities.GeneralPropertyException;

import edu.ucsb.nceas.utilities.MetaDataGroup;

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 implements ServiceInterface {

	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"; 

	private static final String MAIN_CONFIG_NAME = "metacat.properties";

	private static final String ORG_CONFIG_NAME = "org.properties";

	private static final String CONFIG_DIR = "WEB-INF";

	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 orgBackupPropertiesFilePath = null;

	private static SortedProperties orgBackupProperties = null;

	private static String orgMetaDataFilePath = null;

	private static PropertiesMetaData orgMetaData = 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(ServletContext servletContext) throws ServiceException {

		try {

		initialize(servletContext);

		} catch (GeneralPropertyException gpe) {

			throw new ServiceException("Properties problem while initializing PropertyService: " + gpe.getMessage());

		} catch (IOException ioe) {

			throw new ServiceException("I/O Problem while initializing PropertyService: " + ioe.getMessage());

		}

	}

	/**

	 * Get the single instance of AuthAdmin.

	 * 

	 * @param servletContext the context we will use to get relative paths

	 * @return the single instance of AuthAdmin

	 */

	public static PropertyService getInstance(ServletContext servletContext) throws ServiceException {

		if (propertyService == null) {

			propertyService = new PropertyService(servletContext);

		}

		return propertyService;

	}

	/**

	 * Initialize the singleton.

	 * 

	 * @param servletContext the context we will use to get relative paths

	 */

	public void initialize(ServletContext servletContext)

			throws IOException, GeneralPropertyException {

		logMetacat.debug("Initializing PropertyService");

		// mainProperties will hold the primary configuration values for metacat.

		mainPropertiesFilePath = servletContext.getRealPath(CONFIG_DIR) + FileUtil.getFS() + MAIN_CONFIG_NAME;

		if (mainProperties == null) {

			mainProperties = new SortedProperties(mainPropertiesFilePath);

			mainProperties.load();

		}

		try {

			// 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 = servletContext.getRealPath(CONFIG_DIR) + FileUtil.getFS() + MAIN_CONFIG_NAME + ".metadata.xml";

			if (mainMetaData == null) {

				mainMetaData = new PropertiesMetaData(propertiesMetaDataFilePath);

			}

			// orgMetaData holds configuration information about organization level 

			// properties.  these are mostly ldap information relative to an 

			// organization. This is primarily used to display input fields on 

			// the organization configuration page. The information is retrieved 

			// from an xml metadata file dedication just to organization properties.

			orgMetaDataFilePath = servletContext.getRealPath(CONFIG_DIR) + FileUtil.getFS() + ORG_CONFIG_NAME + ".metadata.xml";

			if (orgMetaData == null) {

				orgMetaData = new PropertiesMetaData(orgMetaDataFilePath);

			}

		} catch (TransformerException te) {

			throw new GeneralPropertyException(te.getMessage());

		}

		String backupDirPath = getBackupDir();

		// 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 = backupDirPath + FileUtil.getFS() + MAIN_CONFIG_NAME + ".backup";

		if (mainBackupProperties == null) {

			mainBackupProperties = 

				new SortedProperties(mainBackupPropertiesFilePath);

			mainBackupProperties.load();

		}

		// The orgBackupProperties hold properties that were backed up the 

		// last time the organizations were 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.

		orgBackupPropertiesFilePath = backupDirPath + FileUtil.getFS() +  ORG_CONFIG_NAME + ".backup";

		if (orgBackupProperties == null) {

			orgBackupProperties = 

				new SortedProperties(orgBackupPropertiesFilePath);

			orgBackupProperties.load();

		}

	}

	/**

	 * 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 organizational 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 getOrgBackupProperties() {

		return orgBackupProperties;

	}

	/**

	 * 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 organization 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 getOrgMetaData() {

		return orgMetaData;

	}

	/**

	 * Writes out backup configurable properties to a file.

	 */

	public static void persistMainBackupProperties(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(mainBackupPropertiesFilePath);

			// Populate the backup properties for main metacat properties using

			// the associated metadata file

			PropertiesMetaData mainMetadata = new PropertiesMetaData(propertiesMetaDataFilePath);

			Set<String> mainKeySet = mainMetadata.getKeys();

			for (String propertyKey : mainKeySet) {

				backupProperties.addProperty(propertyKey, getProperty(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());

		}

	}

	/**

	 * Writes out backup configurable properties to a file.

	 */

	public static void persistOrgBackupProperties(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(orgBackupPropertiesFilePath);

			// Populate the backup properties for organization properties using

			// the associated metadata file

			PropertiesMetaData orgMetadata = new PropertiesMetaData(orgMetaDataFilePath);

			// Here we get the group definition for group 1 from the org

			// metadata.  Group 1 should be global values across all 

			// organizations.  We then get all properties metadata associated 

			// with group 1, iterate through it and set it in the backup

			// properties.

			MetaDataGroup globalGroup = orgMetadata.getGroup(1);

			SortedMap<Integer, MetaDataProperty> globalPropertyMap = 

				orgMetadata.getPropertiesInGroup(globalGroup.getIndex());

			for (MetaDataProperty property : globalPropertyMap.values()) {

				String orgPropertyName = property.getKey();

				backupProperties.addProperty(orgPropertyName, getProperty(orgPropertyName));

			}

			// We do the same thing here for organization specific properies

			// with the addition that we need to iterate through all available 

			// organizations.  For instance, a metadata section that defines a 

			// property as "ldap.base" will be entered into the metacat.properties

			// file with a key of "ldap.base.NCEAS" for the NCEAS organization. 

			// This will be repeated for all available organizations.

			MetaDataGroup orgGroup = orgMetadata.getGroup(2);

			SortedMap<Integer, MetaDataProperty> orgPropertyMap = orgMetadata

					.getPropertiesInGroup(orgGroup.getIndex());

			for (String orgName : LDAPUtil.getOrganizations()) {

				for (MetaDataProperty property : orgPropertyMap.values()) {

					String orgPropertyName = property.getKey() + "." + orgName;

					backupProperties.addProperty(orgPropertyName, getProperty(orgPropertyName));

				}

			}

			// 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 (UtilException ue) {

			throw new GeneralPropertyException("Could not get organizations: " + ue.getMessage());

		}

	}

	/**

	 * Gets the backup properties directory

	 * 

	 * TODO MCD figure out how to expand this.  At least for Windows

	 * 

	 * @return a string which holds the name of the backup directory. returns

	 *         null if directory could not be created.

	 */

	public static String getBackupDir() {

		return "/var/metacat/.metacat";

	}

	/**

	 * 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 UtilException {

		try {

			return !PropertyService.getProperty("configutil.propertiesConfigured").equals(

					PropertyService.UNCONFIGURED);

		} catch (PropertyNotFoundException pnfe) {

			throw new UtilException("Could not determine if properties 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 propertyName) 

			throws GeneralPropertyException {

		String value = PropertyService.getProperty(propertyName);

		String newValue = request.getParameter(propertyName);

		if (newValue != null && !newValue.equals(value)) {

			PropertyService.setPropertyNoPersist(propertyName, newValue);

		}

	}

}