Metacat

/**

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

 */

import java.io.IOException;

import java.util.HashMap;

import java.util.Vector;

import javax.xml.transform.TransformerException;

import org.apache.log4j.Logger;

import edu.ucsb.nceas.metacat.shared.MetacatUtilException;

import edu.ucsb.nceas.metacat.shared.ServiceException;

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 skin configuration utility

 */

	private static HashMap<String, SortedProperties> skinPropertiesMap = null;

	private static HashMap<String, PropertiesMetaData> skinMetaDataMap = null;

	/**

	 * private constructor since this is a singleton

	 *

	 *            the context we will use to get relative paths

			throw new ServiceException(

		} catch (IOException ioe) {

		}

	}

	 *            the context we will use to get relative paths

		return skinService;

	}

			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

	 */

			ServiceException {

		logMetacat.debug("Initializing SkinService");

		skinNames = SkinUtil.getSkinNames();

		skinPropertiesMap = new HashMap<String, SortedProperties>();

		skinBackupPropertiesMap = new HashMap<String, SortedProperties>();

		skinMetaDataMap = new HashMap<String, PropertiesMetaData>();

		try {

			for (String skinName : skinNames) {

						+ ".properties";

				if (FileUtil.getFileStatus(propertyFilePath) < FileUtil.EXISTS_READ_WRITABLE) {

					logMetacat.error("Skin property file: " + propertyFilePath

				}

				skinProperties.load();

				skinPropertiesMap.put(skinName, skinProperties);

						+ ".properties.metadata.xml";

					PropertiesMetaData skinMetaData = new PropertiesMetaData(metaDataFilePath);

					skinMetaDataMap.put(skinName, skinMetaData);

					logMetacat.error("Could not find skin property metadata file for skin: "

							+ skinName + " at: " + metaDataFilePath

							+ ". This skin will not be available.");

					continue;

						+ ".properties.backup";

							backupPropertyFilePath);

					skinBackupPropertiesMap.put(skinName, skinBackupProperties);

				} else {

							+ skinName + " at: " + backupPropertyFilePath);

		} catch (TransformerException te) {

			throw new GeneralPropertyException(te.getMessage());

		}

	}

	/**

	 * specific skin.

	 *            the skin for which we want to retrieve the property

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

					+ skinName);

		return skinProperties.getProperty(propertyName);

	}

	 *

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

		if (skinProperties == null) {

					+ skinName);

	}

	/**

	 * Get a Set of all property names that start with the groupName prefix.

	 *

	 * @param groupName

	 *            the prefix of the keys to search for.

			throws PropertyNotFoundException {

		if (skinProperties == null) {

					+ skinName);

	}

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

	}

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

	}

	/**

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

	}

	 * 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

	 */

			throws IOException, GeneralPropertyException {

		if (skinProperties == null) {

					+ 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

	 */

			String newValue) throws GeneralPropertyException {

		if (skinProperties == null) {

					+ skinName);

		skinProperties.setPropertyNoPersist(propertyName, newValue);

	}

	/**

	 * will be preserved.

			GeneralPropertyException {

		if (skinProperties == null) {

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

	 */

			throws GeneralPropertyException {

			String metaDataFilePath = ServiceService.getRealSkinDir() + FileUtil.getFS()

					+ skinName + FileUtil.getFS() + skinName + ".properties.metadata.xml";

					+ ".properties.backup";

			// Use the metadata to extract configurable properties from the

			// overall properties list, and store those properties.

					backupPropertyFilePath);

			// the associated metadata file

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

				}

			}

			backupProperties.store();

		} catch (TransformerException te) {

					"Could not transform backup properties xml: " + te.getMessage());

					"Could not backup configurable properties: " + ioe.getMessage());

			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

	 */

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

					PropertyService.UNCONFIGURED);

		} catch (PropertyNotFoundException pnfe) {

		}

	}

	 * 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

	 */

			String propertyName) throws GeneralPropertyException {

	 * 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

	 */

			String propertyName) throws GeneralPropertyException {

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

		}

	}

	 * false if -- dev.runConfiguration=false and -- backup properties file

	 * exists Note that dev.runConfiguration should only be set to false when

	 *

	 *         backup properties file exists.

	public static boolean bypassConfiguration() {

		boolean bypass = false;

		// this every time we hit metacat.

			return bypass;

		}

		try {

					.getProperty("dev.runConfiguration");

			if (!bypass) {

				bypassAlreadyChecked = true;

				return false;

			}

			// get the backup properties and replace existing properties with

				SortedProperties backupProperties = getBackupProperties(skinName);

					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;

	}