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

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

import javax.servlet.ServletContext;

import javax.servlet.http.HttpServletRequest;

import javax.xml.transform.TransformerException;

import org.apache.log4j.Logger;

import edu.ucsb.nceas.utilities.FileUtil;

import edu.ucsb.nceas.utilities.GeneralPropertyException;

import edu.ucsb.nceas.utilities.PropertyNotFoundException;

import edu.ucsb.nceas.utilities.SortedProperties;

/**

 * A suite of utility classes for the metadata configuration utility

 */

	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 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 SortedProperties authBackupProperties = null;

	private static PropertiesMetaData authMetaData = null;

	private static String testConfigDir = null;

	/**

	 * private constructor since this is a singleton

	 *

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

	 */

					"PropertyService: " + gpe.getMessage());

					"PropertyService: " + ioe.getMessage());

	}

	/**

			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;

	}

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

		}

	 * Initialize the singleton.

	 *

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

	 */

			throws IOException, GeneralPropertyException, ServiceException {

		logMetacat.debug("Initializing PropertyService");

		if (testInstance) {

			configDir = testConfigDir;

		} else {

			configDir = ServiceService.getRealConfigDir();

		}

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

		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

			// from an xml metadata file dedicated just to auth properties.

			authMetaDataFilePath = configDir + FileUtil.getFS() + AUTH_CONFIG_NAME + ".metadata.xml";

			throw new GeneralPropertyException(te.getMessage());

		}

		if (backupBasePath == null || backupBasePath.equals("")) {

			backupBasePath = SystemUtil.discoverExternalBaseDir();

		}

		// if backupBasePath 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 (backupBasePath != null && !backupBasePath.equals("")) {

			setProperty("application.backupDir", backupBasePath);

			String backupDirPath = backupBasePath + FileUtil.getFS() + ".metacat";

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

			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 =

				backupDirPath + FileUtil.getFS() + AUTH_CONFIG_NAME + ".backup";

			authBackupProperties = new SortedProperties(authBackupPropertiesFilePath);

			authBackupProperties.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

	 */

			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

	 */

	}

	/**

	 * Save the properties to a properties file. Note, the

	 * order and comments will be preserved.

	 */

	}

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

	}

	/**

	 * 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

	 */

		return authBackupProperties;

	/**

	 * describes the attributes of configurable properties.

	 *

	 * @return a PropertiesMetaData object with the main properties metadata

	 */

	public static PropertiesMetaData getMainMetaData() {

		return mainMetaData;

	}

	/**

	 *

	 * @return a PropertiesMetaData object with the organization properties

	 *         metadata

	 */

		return authMetaData;

	/**

	 */

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

			Map<String, MetaDataProperty> mainKeyMap = mainMetadata.getProperties();

			Set<String> mainKeySet = mainKeyMap.keySet();

				MetaDataProperty metaData = mainKeyMap.get(propertyKey);

				if (!metaData.getFieldType().equals(MetaDataProperty.PASSWORD_TYPE)) {

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

				}

			// store the properties to file

			backupProperties.store();

				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.

	 */

		// overall properties list, and store those properties.

		try {

			SortedProperties backupProperties =

			Map<String, MetaDataProperty> authKeyMap = authMetadata.getProperties();

			Set<String> authKeySet = authKeyMap.keySet();

				MetaDataProperty metaData = authKeyMap.get(propertyKey);

				if (!metaData.getFieldType().equals(MetaDataProperty.PASSWORD_TYPE)) {

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

				}

			// store the properties to file

			backupProperties.store();

				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

	 */

			if (propertiesConfigured != null && !propertiesConfigured.equals(UNCONFIGURED)) {

				return true;

			}

			return false;

			throw new UtilException("Could not determine if properties are configured: "

					+ pnfe.getMessage());

		}

	}

	/**

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

	}

	/**

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

	 */

				throw new ServiceException(

						"Attempting to do bypass when system is not configured for it.");

			}

			// get the backup properties and replace existing properties with

			// backup values.  We do this for main and org properties.

			Vector<String> backupPropertyNames =

				mainBackupProperties.getPropertyNames();

			for (String backupPropertyName : backupPropertyNames) {

				String value = mainBackupProperties.getProperty(backupPropertyName);

				setPropertyNoPersist(backupPropertyName, value);

			}

			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.databaseConfigured", "true");

			persistProperties();

		} catch (PropertyNotFoundException pnfe) {

		bypassAlreadyChecked = true;

	}

	/**

	 * 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

	 */

		String value = PropertyService.getProperty(propertyName);

		String newValue = request.getParameter(propertyName);

			PropertyService.setPropertyNoPersist(propertyName, newValue.trim());

	}

}