Metacat

/**

 *    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

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

import java.net.URL;

import java.net.MalformedURLException;

import java.sql.DriverManager;

import java.sql.SQLException;

import java.util.Enumeration;

 * A suite of utility classes for the metadata catalog server

 */

public class MetaCatUtil {

  private static PropertyResourceBundle options = null;

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

  /**

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

   */

  static {

    try {

      dbAdapter = (DBAdapter)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;

//  }

   *

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

    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)

      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

    // Get the configuration file information

    PropertyResourceBundle options = (PropertyResourceBundle)

                                     PropertyResourceBundle.getBundle(propFile);

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

    return value;

   * info from the properties file

   */

  public Connection openDBConnection()

                throws SQLException, ClassNotFoundException {

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

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

  }

  /**

   *

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

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

     return conn;

  }

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

    Connection conn = null;

    Enumeration connections = connectionPool.keys();

    synchronized (connectionPool) {

      while (connections.hasMoreElements()) {

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

            conn = openDBConnection();

            // update the pool to show this one taken

            connectionPool.put(conn, Boolean.TRUE);

            return conn;

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

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

        }

      }

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

    // we need to make more

    int incConn = (new Integer(getOption("incrementConnections"))).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

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

    }

    return getConnection();

  }

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

  public void returnConnection (Connection returned) {

    Connection conn;

    Enumeration connections = connectionPool.keys();

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

        while (connections.hasMoreElements()) {

          conn = (Connection)connections.nextElement();

          if ( conn == returned ) {

            break;

    } catch (SQLException e) {}

  public int getPoolSize() {

    return connectionPool.size();

  }

  public void closeConnections() {

    Connection conn;

    Enumeration connections = connectionPool.keys();

    while (connections.hasMoreElements()) {

        conn = (Connection)connections.nextElement();

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

              conn.close();

            }

        } catch (SQLException e) {}

  }

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

     }

  }

  /**

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

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

        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) != '=') {

            }

          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;

          temp += query.charAt(i);

      }

    }

    return parameters;

  }

  /**

   *

   * @param flag an integer indicating the message number

   */

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

    }

  }