Metacat

/**

 *  '$RCSfile$'

 *    Purpose: A Class that implements utility methods for a metadata catalog

 *  Copyright: 2000 Regents of the University of California and the

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Matt Jones, Jivka Bojilova

 *    Release: @release@

 * 

 *   '$Author: tao $'

 *     '$Date: 2002-05-06 11:30:14 -0700 (Mon, 06 May 2002) $'

 * '$Revision: 1053 $'

 *

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

import java.io.File;

import java.net.URL;

import java.net.MalformedURLException;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.SQLException;

import java.util.PropertyResourceBundle;

import java.util.Hashtable;

import java.util.Enumeration;

import java.util.Vector;

import edu.ucsb.nceas.dbadapter.AbstractDatabase;

/**

 * A suite of utility classes for the metadata catalog server

 */

public class MetaCatUtil {

  public static AbstractDatabase dbAdapter;

  private static PropertyResourceBundle options = null;

  private static String propertiesFile = "edu.ucsb.nceas.metacat.metacat";

  private static boolean debug = false;

  private Hashtable connectionPool = new Hashtable();

  /** 

   * Determine our db adapter class and create an instance of that class

   */

  static {

    try {

      dbAdapter = (AbstractDatabase)createObject(getOption("dbAdapter"));

    } catch (Exception e) {

      System.err.println("Error in MetaCatUtil static block:" + e.getMessage());

    }

  }

// CONSTRUCTORS NOT NEEDED

//  /**

//   * Construct an instance of the utility class

//   */

//  public MetaCatUtil() {

//

//    options = (PropertyResourceBundle)

//          PropertyResourceBundle.getBundle(propertiesFile);

//  }

//  

//  /**

//   * This constructor allows the usage of a different properties file

//   * @param propFile the properties file that you wish to use.

//   */

//  public MetaCatUtil(String propFile)  {

//

//    propertiesFile = propFile;

//  }

  /**

   * Instantiate a class using the name of the class at runtime

   *

   * @param className the fully qualified name of the class to instantiate

   */

  public static Object createObject(String className) throws Exception {

    Object object = null;

    try {

      Class classDefinition = Class.forName(className);

      object = classDefinition.newInstance();

    } catch (InstantiationException e) {

      throw e;

    } catch (IllegalAccessException e) {

      throw e;

    } catch (ClassNotFoundException e) {

      throw e;

    }

    return object;

  }

  /** 

   * Utility method to get an option value from the properties file

   *

   * @param optionName the name of the option requested

   */

  public static String getOption(String optionName) {

      // Get the configuration file information

      if (options == null) {

        options = (PropertyResourceBundle)

          PropertyResourceBundle.getBundle(propertiesFile);

      }

      String value = (String)options.handleGetObject(optionName);

      return value;

  }

  /** 

   * Utility method to get an option value from a properties file

   *

   * @param optionName the name of the option requested

   * @param propFile the name of the file where to get the properties from

   */

  public String getOption(String optionName, String propFile) {

    // Get the configuration file information

    PropertyResourceBundle options = (PropertyResourceBundle)

                                     PropertyResourceBundle.getBundle(propFile);

    String value = (String)options.handleGetObject(optionName);

    return value;

  }

  /** 

   * Utility method to establish a JDBC database connection using connection

   * info from the properties file

   */

  public Connection openDBConnection()

                throws SQLException, ClassNotFoundException {

    return openDBConnection(getOption("dbDriver"), getOption("defaultDB"),

                     getOption("user"), getOption("password"));

  }

  /** 

   * Utility method to establish a JDBC database connection 

   *

   * @param dbDriver the string representing the database driver

   * @param connection the string representing the database connectin parameters

   * @param user name of the user to use for database connection

   * @param password password for the user to use for database connection

   */

  public static Connection openDBConnection(String dbDriver, String connection,

                String user, String password)

                throws SQLException, ClassNotFoundException {

     // Load the Oracle JDBC driver

     Class.forName (dbDriver);

     debugMessage("Opening connection: " + connection);

     // Connect to the database

     Connection conn = DriverManager.getConnection( connection, user, password);

     return conn;

  }

  /* Utility method to create and return a pool of Connection objects */

  public Hashtable getConnectionPool()

                throws SQLException, ClassNotFoundException {

    int initConn = (new Integer(getOption("initialConnections"))).intValue();

    for ( int i = 0; i < initConn; i++ ) {

        connectionPool.put( openDBConnection(), Boolean.FALSE );

    }    

    return connectionPool;

  }

  /* Utility method to get a unused Connection object from the pool */

  public Connection getConnection()

                throws SQLException, ClassNotFoundException, Exception 

  {

    Connection conn = null;

    Enumeration connections = connectionPool.keys();

    synchronized (connectionPool) {

      while (connections.hasMoreElements()) {

        conn = (Connection)connections.nextElement();

        Boolean b = (Boolean)connectionPool.get(conn);

        if (conn == null || conn.isClosed()) {

            // closed connection; replace it

            conn = openDBConnection();

            // update the pool to show this one taken

            connectionPool.put(conn, Boolean.TRUE);  

            return conn;

        } else if (b == Boolean.FALSE) {

            // unused connection; test if it works and get it

            try {

                conn.setAutoCommit(true);

            } catch (SQLException e) {

                // problem with the connection, replace it

                conn = openDBConnection();

            }    

            // update the pool to show this one taken

            connectionPool.put(conn, Boolean.TRUE);    

            return conn;

        }    

      }  

    }   

    // If we get here, there no free connections;

    // we need to make more

    int incConn = (new Integer(getOption("incrementConnections"))).intValue();

    int maxConn = (new Integer(getOption("maximumConnections"))).intValue();

    int k = connectionPool.size();

    if ( k >= maxConn ) {

        throw new Exception("The maximum of " + maxConn + 

                            " open db connections is reached." +

                            " New db connection to MetaCat" +

                            " cannot be established.");

    }    

    // decide how many new connections to open; no more than the maximum

    if ( incConn > maxConn - k ) { incConn = maxConn - k; }

    // get them

    for ( int i = 0; i < incConn; i++ ) {

        connectionPool.put( openDBConnection(), Boolean.FALSE );

    }

    // Recurse to get one of the new connections

    return getConnection();

  }

  /* Utility method to give the connection back to the pool */

  public void returnConnection (Connection returned) {

    Connection conn;

    Enumeration connections = connectionPool.keys();

    try {

      if ( (returned != null) && !(returned.isClosed()) ) {

        while (connections.hasMoreElements()) {

          conn = (Connection)connections.nextElement();

          if ( conn == returned ) {

            connectionPool.put( conn, Boolean.FALSE );

            break;

          }    

        }    

      }

    } catch (SQLException e) {}    

  }

  /* Return the size of the pool */

  public int getPoolSize() {

    return connectionPool.size();

  }

  /* Utility method to close all the connection from the pool */

  public void closeConnections() {

    Connection conn;

    Enumeration connections = connectionPool.keys();

    while (connections.hasMoreElements()) {

        conn = (Connection)connections.nextElement();

        try {

            if ( (conn != null) && !(conn.isClosed()) ) {

              conn.close();

            }    

        } catch (SQLException e) {}    

    }

  }

  /** Utility method to convert a file handle into a URL */

  public static URL fileToURL(File file)

  {

     String path = file.getAbsolutePath();

     String fSep = System.getProperty("file.separator");

     if (fSep != null && fSep.length() == 1)

       path = path.replace(fSep.charAt(0), '/');

     if (path.length() > 0 && path.charAt(0) != '/')

       path = '/' + path;

     try {

       return new URL("file", null, path);

     }

     catch (java.net.MalformedURLException e) {

       /* According to the spec this could only happen if the file

          protocol were not recognized. */

       throw new Error("unexpected MalformedURLException");

     }

  }

  /** 

   * Utility method to parse the query part of a URL into parameters. This

   * method assumes the format of the query par tof the url is an 

   * ampersand separated list of name/value pairs, with equal signs separating

   * the name from the value (e.g., name=tom&zip=99801 ). Returns a

   * has of the name value pairs, hashed on name.

   */

  public static Hashtable parseQuery(String query) throws MalformedURLException

  {

    String[][] params = new String[200][2];

    Hashtable parameters = new Hashtable();

    String temp = "";

    boolean ampflag = true;

    boolean poundflag = false;

    int arrcount = 0;

    if ( query != null ) {

      for (int i=0; i < query.length(); i++) { 

        // go throught the remainder of the query one character at a time.

        if (query.charAt(i) == '=') { 

          // if the current char is a # then the preceding should be a name

          if (!poundflag && ampflag) {

            params[arrcount][0] = temp.trim();

            temp = "";

          } else { 

            //if there are two #s or &s in a row throw an exception.

            throw new MalformedURLException("metacatURL: Two parameter names "+

                                            "not allowed in sequence");

          }

          poundflag = true;

          ampflag = false;

        } else if (query.charAt(i) == '&' || i == query.length()-1) { 

          //the text preceding the & should be the param value.

          if (i == query.length() - 1) { 

            //if at the end of the string grab the last value and append it.

            if (query.charAt(i) != '=') { 

            //ignore an extra & on the end of the string

              temp += query.charAt(i);

            }

          }

          if (!ampflag && poundflag) {

            params[arrcount][1] = temp.trim();

            parameters.put(params[arrcount][0], params[arrcount][1]);

            temp = "";

            arrcount++; //increment the array to the next row.

          } else { 

            //if there are two =s or &s in a row through an exception

            throw new MalformedURLException("metacatURL: Two parameter values "+

                                            "not allowed in sequence");

          }

          poundflag = false;

          ampflag = true;

        } else { 

          //get the next character in the string

          temp += query.charAt(i);

        }

      }

    }

    return parameters;

  }

   /** 

   * Utility method to print debugging messages. User can set debug level

   * for this message. The number is fewer, the message is more important

   * @param msg, the content of the message

   * @param debugLevel, an integer indicating the message debug leve

   */

  public static void debugMessage(String msg, int debugLevel) 

  {

    int limit = 1;

    try 

    {

      limit=Integer.parseInt(getOption("debuglevel"));

    }

    catch (Exception e)

    {

      System.out.println(e.getMessage());

    }

    //don't allow the user set debugLevel less than or equals 0

    if (debugLevel<=0)

    {

      debugLevel=1;

    }

    if (debugLevel < limit) 

    {

      System.err.println(msg);

    }

  }

  /** 

   * Utility method to print debugging messages

   *

   * @param flag an integer indicating the message number

   */

  public static void debugMessage(int flag) {

    if (debug) {

      System.err.println("DEBUG FLAG: " + flag);

    }

  }

  /** 

   * Utility method to print debugging messages

   *

   * @param flag an integer indicating the message number

   */

  public static void debugMessage(String msg) {

    if (debug) {

      System.err.println(msg);

    }

  }

  public static void debug(String msg)

  {

    if(debug)

    {

      System.err.println(msg);

    }

  }

  public static Vector getOptionList(String optiontext)

  {

    Vector options = new Vector();

    if(optiontext.indexOf(",") == -1)

    {

      options.addElement(optiontext);

      return options;

    }

    while(optiontext.indexOf(",") != -1)

    {

      String s = optiontext.substring(0, optiontext.indexOf(","));

      options.addElement(s.trim());

      optiontext = optiontext.substring(optiontext.indexOf(",") + 1, 

                                        optiontext.length());

      if(optiontext.indexOf(",") == -1)

      { //catch the last list entry

        options.addElement(optiontext.trim());

      }

    }

    return options;

  }

  /** Normalizes the given string. Taken from configXML.java*/

  public static String normalize(String s)

  {

    StringBuffer str = new StringBuffer();

    int len = (s != null) ? s.length() : 0;

    for (int i = 0; i < len; i++)

    {

      char ch = s.charAt(i);

      switch (ch)

      {

      case '<':

      {

        str.append("<");

        break;

      }

        case '>':

      {

        str.append(">");

        break;

      }

      case '&':

      {

        str.append("&");

        break;

      }

      case '"':

      {

        str.append(""");

        break;

      }

      case '\r':

      case '\n':

      {

        // else, default append char

      }

      default:

      {

        str.append(ch);

      }

      }

    }

    return (str.toString());

  } 

  /** 

   * Utility method to get docid from a given string

   * @param string, the given string should be these two format:

   *              1) str1.str2  in this case docid= str1.str2

   *              2) str1.str2.str3, in this case docid =str1.str2

   * @param the sperator char

   */

  public static String getDocIdFromString(String str)

  {

    String docId = null;

    int dotNumber = 0;//count how many dots in given string

    int indexOfLastDot = 0;

    //assume that seperator is one charactor string

    char seperator=getOption("accNumSeparator").charAt(0);

    for (int i=0; i<str.length(); i++)

    {

      if ( str.charAt(i)==seperator)

      {

        dotNumber++;//count how many dots

        indexOfLastDot=i;//keep the last dot postion

      }

    }//for

    //The string formatt is wrong, because it has more than two or less than

    //one seperator

    if ( dotNumber>2 || dotNumber < 1)

    {

      docId=null;

    }

    else if (dotNumber == 2) //the case for str1.str2.str3

    {

       docId=str.substring(0, indexOfLastDot);

    }

    else if (dotNumber == 1) //the case for str1.str2

    {

      docId=str;

    }

    return docId;  

  }//getDocIdFromString

  /** 

   * Utility method to get version number from a given string

   * @param string, the given string should be these two format:

   *              1) str1.str2(no version)  version =-1;

   *              2) str1.str2.str3, in this case version = str3;

   *              3) other, vresion =-2

   * @param the sperator char

   */

  public static int getVersionFromString(String str)

                                throws NumberFormatException

  {

    int version=-1;

    String versionString=null;

    int dotNumber = 0;//count how many dots in given string

    int indexOfLastDot = 0;

    //assume that seperator is one charactor string

    char seperator=getOption("accNumSeparator").charAt(0);

    for (int i=0; i<str.length(); i++)

    {

      if ( str.charAt(i)==seperator)

      {

        dotNumber++;//count how many dots

        indexOfLastDot=i;//keep the last dot postion

      }

    }//for

    //The string formatt is wrong, because it has more than two or less than

    //one seperator

    if ( dotNumber>2 || dotNumber < 1)

    {

      version=-2;

    }

    else if (dotNumber == 2) //the case for str1.str2.str3

    {

       versionString=str.substring((indexOfLastDot+1), str.length());

       version=Integer.parseInt(versionString);

    }

    else if (dotNumber == 1) //the case for str1.str2

    {

      version=-1;

    }

    return version;  

  }//getVersionFromString

   /**

   * Method to get the name of local replication server

   */

   public String getLocalReplicationServerName()

   {

     String replicationServerName=null;

     String serverHost=null;

     serverHost=getOption("server");

     // append "context/servelet/replication" to the host name

     replicationServerName=serverHost+getOption("replicationpath");

     return replicationServerName;

   }

}