/src/edu/ucsb/nceas/metacat/MetaCatUtil.java - Annotate - Metacat - Ecoinformatics Redmine

metacat/src/edu/ucsb/nceas/metacat/MetaCatUtil.java @ 897

-            jones
+/**
-            jones
+ *  '$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
-            bojilova
+ *    Authors: Matt Jones, Jivka Bojilova
-            jones
+ *    Release: @release@
             jones
-            jones
+ *   '$Author$'
  *     '$Date$'
  * '$Revision$'
             jones
  * 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
-            jones
+ */
 package edu.ucsb.nceas.metacat;
-            jones
+import java.io.File;
 import java.net.URL;
 import java.net.MalformedURLException;
-            jones
+import java.sql.Connection;
 import java.sql.DriverManager;
 import java.sql.SQLException;
-            jones
+import java.util.PropertyResourceBundle;
-            bojilova
+import java.util.Hashtable;
 import java.util.Enumeration;
-            berkley
+import java.util.Vector;
             jones
-            bojilova
+import edu.ucsb.nceas.dbadapter.AbstractDatabase;
             bojilova
-            jones
+/**
  * A suite of utility classes for the metadata catalog server
  */
 public class MetaCatUtil {
-            bojilova
+  public static AbstractDatabase dbAdapter;
-            bojilova
+  private static PropertyResourceBundle options = null;
   private static String propertiesFile = "edu.ucsb.nceas.metacat.metacat";
-            jones
+  private static boolean debug = false;
             bojilova
-            bojilova
+  private Hashtable connectionPool = new Hashtable();
   /**
    * Determine our db adapter class and create an instance of that class
    */
   static {
     try {
-            bojilova
+      dbAdapter = (AbstractDatabase)createObject(getOption("dbAdapter"));
-            bojilova
+    } 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;
 //  }
-            jones
+  /**
-            bojilova
+   * Instantiate a class using the name of the class at runtime
+   *
    * @param className the fully qualified name of the class to instantiate
-            jones
+   */
-            bojilova
+  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)
-            jones
+          PropertyResourceBundle.getBundle(propertiesFile);
             bojilova
       String value = (String)options.handleGetObject(optionName);
       return value;
             jones
             bojilova
   /**
    * 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
-            berkley
+   */
-            bojilova
+  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;
             berkley
             jones
-            jones
+  /**
-            jones
+   * 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"));
+  }
   /**
-            jones
+   * 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);
-            jones
+     debugMessage("Opening connection: " + connection);
-            jones
+     // Connect to the database
      Connection conn = DriverManager.getConnection( connection, user, password);
      return conn;
+  }
             jones
-            bojilova
+  /* 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()
-            jones
+                throws SQLException, ClassNotFoundException, Exception
+  {
             bojilova
     Connection conn = null;
     Enumeration connections = connectionPool.keys();
     synchronized (connectionPool) {
       while (connections.hasMoreElements()) {
             bojilova
-            bojilova
+        conn = (Connection)connections.nextElement();
         Boolean b = (Boolean)connectionPool.get(conn);
             bojilova
-            bojilova
+        if (conn == null || conn.isClosed()) {
-            bojilova
+            // 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) {
-            bojilova
+            // 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);
             bojilova
-            bojilova
+            return conn;
+        }
+      }
             bojilova
             bojilova
     // If we get here, there no free connections;
     // we need to make more
     int incConn = (new Integer(getOption("incrementConnections"))).intValue();
-            bojilova
+    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
-            bojilova
+    for ( int i = 0; i < incConn; i++ ) {
         connectionPool.put( openDBConnection(), Boolean.FALSE );
+    }
             bojilova
-            bojilova
+    // 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();
-            bojilova
+    try {
       if ( (returned != null) && !(returned.isClosed()) ) {
         while (connections.hasMoreElements()) {
           conn = (Connection)connections.nextElement();
           if ( conn == returned ) {
-            bojilova
+            connectionPool.put( conn, Boolean.FALSE );
             break;
             bojilova
             bojilova
             bojilova
     } catch (SQLException e) {}
             bojilova
             bojilova
-            bojilova
+  /* Return the size of the pool */
   public int getPoolSize() {
     return connectionPool.size();
+  }
-            bojilova
+  /* 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();
-            bojilova
+        try {
             if ( (conn != null) && !(conn.isClosed()) ) {
               conn.close();
+            }
         } catch (SQLException e) {}
             bojilova
+  }
             bojilova
-            jones
+  /** 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");
+     }
+  }
   /**
-            jones
+   * 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;
-            bojilova
+    if ( query != null ) {
       for (int i=0; i < query.length(); i++) {
             jones
-            bojilova
+        // 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) != '=') {
-            jones
+            //ignore an extra & on the end of the string
-            bojilova
+              temp += query.charAt(i);
+            }
             jones
             bojilova
           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;
-            jones
+        } else {
-            bojilova
+          //get the next character in the string
           temp += query.charAt(i);
             jones
+      }
+    }
     return parameters;
+  }
   /**
-            jones
+   * Utility method to print debugging messages
+   *
    * @param flag an integer indicating the message number
    */
-            jones
+  public static void debugMessage(int flag) {
     if (debug) {
       System.err.println("DEBUG FLAG: " + flag);
+    }
             jones
             jones
   /**
    * 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);
+    }
+  }
             berkley
   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;
+  }
             berkley
   /** 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("&lt;");
         break;
+      }
         case '>':
+      {
         str.append("&gt;");
         break;
+      }
       case '&':
+      {
         str.append("&amp;");
         break;
+      }
       case '"':
+      {
         str.append("&quot;");
         break;
+      }
       case '\r':
       case '\n':
+      {
         // else, default append char
+      }
       default:
+      {
         str.append(ch);
+      }
+      }
+    }
     return (str.toString());
+  }
             jones

Project

General

Profile

Metacat