Kepler

/**

 *    '$RCSfile: Config.java,v $'

 *

 *     '$Author: barseghian $'

 *       '$Date: 2007/10/11 00:36:37 $'

 *   '$Revision: 1.22 $'

 *

 *  For Details: http://kepler.ecoinformatics.org

 *

 * Copyright (c) 2003 The Regents of the University of California.

 * All rights reserved.

 *

 * Permission is hereby granted, without written agreement and without

 * license or royalty fees, to use, copy, modify, and distribute this

 * software and its documentation for any purpose, provided that the

 * above copyright notice and the following two paragraphs appear in

 * all copies of this software.

 *

 * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY

 * FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES

 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN

 * IF THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY

 * OF SUCH DAMAGE.

 *

 * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,

 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE

 * PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY

 * OF CALIFORNIA HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT,

 * UPDATES, ENHANCEMENTS, OR MODIFICATIONS.

 */

package org.ecoinformatics.util;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.InputStream;

import java.util.Collections;

import java.util.Hashtable;

import java.util.List;

import java.util.Map;

import java.util.Vector;

import javax.xml.transform.TransformerException;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.apache.xpath.XPathAPI;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;

import edu.ucsb.nceas.configxml.ConfigXML;

import edu.ucsb.nceas.configxml.exception.ElementNotFoundException;

import edu.ucsb.nceas.configxml.exception.IndexTooLargeException;

import java.net.URL;

/**

 *

 * configuration file routines

 *

 */

public class Config

{

  //private static final String configfilename = "kepler/config.xml";

  private static final String configfilename = "config.xml";

  private static final String settingsdir = ".kepler";

  // Define useful static strings.  At some point in time, these could be moved

  // into the config.xml file, environment variable, or something else

  // which could move this directory to another location.

  // KEPLER_USER_DIR is returned by Config.getUserDirPath().

  private static final String KEPLER_USER_DIR = System.getProperty("user.home")

                + File.separator + settingsdir + File.separator;

  // KEPLER_CACHE_DIR is returned by Config.getCacheDirPath().

  private static final String KEPLER_CACHE_DIR = KEPLER_USER_DIR + "cache" + File.separator;

  /**

   * The singleton instance.

   */

  private static Config configure ;

  static {

	  configure = new Config();

  }

  private static Log log;

  static {

	  log = LogFactory.getLog("org.ecoinformatics.util.Config");

  }

  // Instance variables.

  /**

   * The underlying ConfigXML object.

   */

  private ConfigXML config;

  /**

   * Error indicator.  Set to true if ConfigXML has problems.

   */

  private boolean error = false;

  /**

   * Method for get object as a singleton class

   * @return Config

   */

  public static Config getInstance()

  {

    return configure;

  }

  /*

   * Constructor for ConfigDatasource.

   * @throws FileNotFoundException

   * @throws Exception

   */

  private Config()

  {

    try

    {

        InputStream is = this.getClass().getClassLoader().getResourceAsStream(configfilename);

        if (is == null) {

            throw new FileNotFoundException("Failed to find \"" 

                    + configfilename + "\" as a resource");

        }

	    URL configFileURL = this.getClass().getClassLoader().getSystemResource(configfilename);

	    File configFile = new File(configFileURL.toURI());

	    config = new ConfigXML( is, configFile.getAbsolutePath() );

        //config = new ConfigXML(configfilename);

    }

    catch(FileNotFoundException fnfe)

    {

      error = true;

      throw new RuntimeException("Config file not found at " + configfilename, fnfe );

    }

    catch(Exception e)

    {

      error = true;

      throw new RuntimeException("Unspecified error creating config object: ", e );

    }

  }

  /**

   * Method to get a string value from config.xml base on given element path

   * @param path String

   * @return String

   */

  public static String getValue(String path)

  {

    Config configInstance = Config.getInstance();

    return configInstance.getValueFromPath(path);

  }

  private String getValueFromPath(String path)

  {

    String value = null;

    if ( error ) {

    	return value;

    }

    if ( path == null ) {

    	return value;

    }

    	try {

    		Vector valueVector = config.getValuesForPath(path);

            value = (String) valueVector.elementAt(0);

    	}

    	catch ( ElementNotFoundException e1 ) {

    		log.debug("Element " + path + " not found");

    	}

    	catch ( Exception e2 ) {

    		log.error("Exception occurred:", e2 );

    	}

    log.debug("The value for path " + path + " in config.xml is " + ((value==null) ? "null" : value) );

    return value;

  }//getValues

  /**

   * Method returns an unmodifiable list of values from config.xml base on given path.

   * If the argument is null or not found in config.xml, return EMPTY_LIST.

   * 

   * @param path String

   * @return Vector

   */

  public static List getList(String path)

  {

    Config configInstance = Config.getInstance();

    return configInstance.getListFromPath(path);

  }

  private List getListFromPath(String path)

  {

	  List value = Collections.EMPTY_LIST;

	    if ( error ) {

	    	return value;

	    }

	    if ( path == null ) {

	    	return value;

	    }

    	try {

    		value = Collections.unmodifiableList(config.getValuesForPath(path));

    	}

    	catch ( ElementNotFoundException e1 ) {

    		log.debug("Element " + path + " not found");

    	}

    	catch ( Exception e2 ) {

    		log.error("Exception occurred:", e2 );

    	}

    return value;

  }//getList

  /**

   * Method to get unmodifiable map for some given pathes in config.xml.

   * If the arguments are invalid (either null) or not found, return an empty map.

   * Here is the segment of config.xml:

   * <parenetElement>

   *   <keyElement>key1</keyElement>

   *   <valueElement>value1</valueElement>

   *  </parentElement>

   *  <parentElement>

   *   <keyElement>key2</keyElement>

   *   <valueElement>value2</valueElement>

   *  </parentElement>

   * The parentPath can be "//parentElement", keyPath should be "./keyElement",

   * and valuePath should be "./valuePath".

   * @param parentPath String

   * @param keyPath String

   * @param valuePath String

   * @throws ElementNotFoundException

   * @throws Exception

   * @return Hashtable

   */

  public static Map getMap(String parentPath, String keyPath, String valuePath)

  {

    Config configInstance = Config.getInstance();

    return configInstance.getMapFromPath(parentPath, keyPath, valuePath);

  }

  private Map getMapFromPath(String parentPath, String keyPath, String valuePath)

  {

    Map map = Collections.EMPTY_MAP;

    if ( error ) {

    	return map;

    }

    if ( parentPath == null || keyPath == null || valuePath == null ) {

    	return map;

    }

    NodeList nl = null;

    try {

        nl = config.getPathContent(parentPath);

    }

    catch ( ElementNotFoundException e1 ) {

    	log.debug("Element " + parentPath + " not found");

    	return map;

    }

    catch ( TransformerException e2 ) {

    	log.error("Transfomer Exception when reading parentPath " + parentPath, e2);

    	return map;

    }

    // At this point nl != null because we didn't get an ElementNotFoundException

    map = new Hashtable();

    try {

        for (int i = 0; i < nl.getLength(); i++)

        {

          Node n = nl.item(i);

          Node keyNode = XPathAPI.selectSingleNode(n, keyPath);

          Node valueNode = XPathAPI.selectSingleNode(n, valuePath);

          if (keyNode == null || valueNode == null)

          {

            log.debug("keyNode or valueNode not found at iteration " + i);

            continue;

          }

          String keyNodeValue = keyNode.getFirstChild().getNodeValue();

          String valueNodeValue = valueNode.getFirstChild().getNodeValue();

          if (keyNodeValue == null || valueNodeValue == null)

          {

        	  log.debug("keyNodeValue or valueNodeValue is null at iteration " + i);

        	  continue;

          }

          log.debug("The value of " + keyPath + " " + keyNodeValue + " and " +

                    " the value of " + valuePath + " " + valueNodeValue +

                    " are put into mapping");

          map.put(keyNodeValue, valueNodeValue);

        } //for

    }

    catch ( TransformerException e ) {

    	log.error("Transfomer Exception in loop ", e);

    }

    return Collections.unmodifiableMap(map);

  }//getMap

  /**

   * Get a node list base on the given xpath in config file

   * @param path String  the xpath

   * @return NodeList

   */

  public static NodeList getNodeListFromPath(String path)

  {

    Config configInstance = Config.getInstance();

    return configInstance.getNodeListFromXPath(path);

  }

  /*

   * This method will get a node list from config file

   */

  private NodeList getNodeListFromXPath(String xpath)

  {

    NodeList list = null;

    if ( error ) {

    	return list;

    }

    try

    {

      list = config.getPathContent(xpath);

    }

    catch (ElementNotFoundException e)

    {

    	log.debug("Element Not found for " + xpath );

    }

    catch ( TransformerException e2 ) {

    	log.error( "Transformer Exception for " + xpath );

    }

    return list;

  }

  /**

   * Method to get error state

   */

  public boolean getErrorState()

  {

    return error;

  }

  /** 

   * Returns the path of the Kepler hidden working directory terminated with File.seperator.

   * This directory is current coded to be ${system.home}/.kepler.

   * 

   * @return the path to the .kepler directory.

   */

  public static String getUserDirPath()

  {

	  return KEPLER_USER_DIR;  

  }

  /**

   * Returns the path to a subdirectory of the working directory.

   * The pathname is normalized to use the system style File.separator.

   * 

   * 

   * @param path a subdirectory of the working directory

   * @return normalized pathname of the subdirectory.

   */

  public static String getUserDirPath( String path )

  {

	  String pdir = path;

	  // In the config file we use unix style separators.

	  // Convert them to windows if on windows.

	  if ( '/' != File.separatorChar ) {

		  pdir.replace('/', File.separatorChar );

	  }

	  pdir = KEPLER_USER_DIR + path;

	  if ( pdir.endsWith(File.separator) ) {

		  return pdir;

	  }

	  else {

		  return pdir + File.separator;

	  }

  }

  /**

   * Returns the path to the Cache working directory terminated with File.seperator.

   * This directory is currently in getUserDirPath() + "cache".

   * 

   * @return the path to the cache directory

   */

  public static String getCacheDirPath()

  {

	  return KEPLER_CACHE_DIR;

  }

  /**

   * Method save. - pass through to ConfigXML member

   * @throws Exception

   */

  public void save() throws Exception

  {

	config.save();

  }

  /**

   * Method set. - pass through to ConfigXML member

   * @param arg1

   * @param arg2

   * @param arg3

   * @throws ElementNotFoundException

   */

  public void set(String arg1, int arg2, String arg3) throws ElementNotFoundException

  {

    config.set(arg1, arg2, arg3);

  }

  /**

   * Method deleteSubFields. - pass through to ConfigXML member

   * @param parentName 

   * @param i 

   * @throws IndexTooLargeException 

   */

  public void deleteSubFields(String parentName, int i) throws IndexTooLargeException 

  {

    config.deleteSubFields(parentName, i);

  }

  /**

   * Method addSubFields. - pass through to ConfigXML member

   * @param parentName

   * @param i

   * @param childName

   * @param value

   * @throws IndexTooLargeException

   */

  public void addSubField(String parentName, int i, String childName, String value)

                       throws IndexTooLargeException

  {

    config.addSubField(parentName, i, childName, value);

  }

}