Metacat

/**

 *  '$RCSfile$'

 *    Purpose: A class represent a DBConnection pool. Another user can use the

 *    object to initial a connection pool, get db connection or return it.

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

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Jing Tao

 *    Release: @release@

 *

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

 */

package edu.ucsb.nceas.metacat;

import java.io.*;

import java.util.Vector;

import java.util.Stack;

import java.util.Hashtable;

import java.util.Enumeration;

/**

 * A class represent a DBConnection pool. Another user can use the

 * object to initial a connection pool, get db connection or return it.

 * This a singleton class, this means only one instance of this class could

 * be in the program at one time.

 */

public class DBConnectionPool

{

  private static DBConnectionPool instance;

  private static Vector connectionPool;

  final static int MAXIMUMCONNECTIONNUMBER=

  final static int INITIALCONNECTIONNUMBER=

  final static int INCREASECONNECTIONNUMBER=

                Integer.parseInt(MetaCatUtil.getOption("incrementConnections"));

  //maximum age for a connection (in milli seconds)

  final static long MAXIMUMAGE =

                  Long.parseLong(MetaCatUtil.getOption("maximumConnectionAge"));

  //maximum connection time for a connection ( in milli second)

  final static long MAXIMUMCONNECTIONTIME =

                 Long.parseLong(MetaCatUtil.getOption("maximumConnectionTime"));

  //maximum number for using a connection.

  final static int MAXIMUMUSAGENUMBER =

                  Integer.parseInt(MetaCatUtil.getOption("maximumUsageNumber"));

  final static int FREE = 0; //status of a connection

  final static int BUSY = 1; //statis of a connection

   * Returns the single instance, creating one if it's the

   * first time this method is called.

   */

  static synchronized public DBConnectionPool getInstance()

    if (instance == null)

    {

      instance = new DBConnectionPool();

    }

    return instance;

  }//getInstance

  /**

   * Method to get the size of DBConnectionPool

   */

  public int getSizeOfDBConnectionPool()

  {

    return connectionPool.size();

  }

  /**

   * This is a private constructor since it is singleton

   */

    initialDBConnectionPool();

  /**

   * Method to initial a pool of DBConnection objects

   */

    DBConnection dbConn = null;

      //create a new object of DBConnection

      //it automatically generate the createtime and tag

      //put DBConnection into vetor

      connectionPool.add(dbConn);

    }

    return connectionPool;

  }

  /**

   * Method to get a DBConnection in connection pool

   */

  public static DBConnection getDBConnection() throws SQLException

  {

    DBConnection db = null;

    //try every DBConnection in the pool

    synchronized(connectionPool)

    {

      for (int i=0; i<connectionPool.size(); i++)

      {

        db = (DBConnection) connectionPool.elementAt(i);

        //check if the connection is free

        if (db.getStatus()==FREE)

        {

          //If this connection is good, return this DBConnection

          if (validateDBConnection(db))

          {

            //set this DBConnection status

            db.setStatus(BUSY);

            //set check out time

            db.setCheckOutTime(System.currentTimeMillis());

            //check it out

            return db;

          }//if

          else//The DBConnection has some problem

          {

            //close this DBConnection

            db.close();

            //remove it form connection pool

            connectionPool.remove(i);

            //insert a new DBConnection to same palace

            db = new DBConnection();

            connectionPool.insertElementAt(db, i);

          }//else

        }//if

      }//for

    }//sychronize

    //if couldn't get a connection, we should increase DBConnection pool

    //if the connection pool size is less than maximum connection number

    int poolSize = connectionPool.size();

    if ( poolSize < MAXIMUMCONNECTIONNUMBER )

    {

       if ((poolSize+INCREASECONNECTIONNUMBER) < MAXIMUMCONNECTIONNUMBER)

       {

         //if we can create INCREASECONNECTIONNUMBER of new DBConnection

         //add to connection pool

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

         {

           DBConnection dbConn = new DBConnection();

           connectionPool.add(dbConn);

         }//for

       }//if

       else

       {

         //There is no enough room to increase INCREASECONNECTIONNUMBER

         //we create new DBCoonection to Maximum connection number

         for (int i= poolSize+1; i<= MAXIMUMCONNECTIONNUMBER; i++)

         {

           DBConnection dbConn = new DBConnection();

           connectionPool.add(dbConn);

         }//for

       }//else

    }//if

    else

    {

      throw new SQLException("The maximum of " +MAXIMUMCONNECTIONNUMBER +

                            " open db connections is reached." +

                            " New db connection to MetaCat" +

                            " cannot be established.");

    }//else

    //recursive to get new connection

    return getDBConnection();

  }//getDBConnection

   * Method to check if a db connection works fine or not

   * Check points include:

   * 1. check the usageCount if it is too many

   * 2. check the dbconne age if it is too old

   * 3. check the connection time if it is too long

   * 4. run simple sql query

   *

   * @param dbConn, the DBConnection object need to check

   */

  private static boolean validateDBConnection (DBConnection dbConn)

  {

    Connection conn = null;

    //Check if the DBConnection usageCount if it is too many

    if (dbConn.getUsageCount() >= MAXIMUMUSAGENUMBER )

    {

      MetaCatUtil.debugMessage("Connection usageCount is too many: "+

      dbConn.getUsageCount(), 50);

      return false;

    }

    //Check if the DBConnection has too much connection time

    if (dbConn.getConnectionTime() >= MAXIMUMCONNECTIONTIME)

    {

      MetaCatUtil.debugMessage("Connection has too much connection time: "+

      dbConn.getConnectionTime(), 50);

      return false;

    }

    //Check if the DBConnection is too old

    if (dbConn.getAge() >=MAXIMUMAGE)

    {

      MetaCatUtil.debugMessage("Connection is too old: "+dbConn.getAge(), 50);

      return false;

    }

    //Try to run a simple query

    conn = dbConn.getConnection();

    try

    {

      long startTime=System.currentTimeMillis();

      conn.getMetaData();

      long stopTime=System.currentTimeMillis();

      //increase one usagecount

      dbConn.increaseUsageCount(1);

      //increase connection time

      dbConn.setConnectionTime(stopTime-startTime);

    catch (Exception e)

    {

      MetaCatUtil.debugMessage("Error in validateDBConnection: "

                                +e.getMessage(), 30);

      return false;

    }

    return true;

  }//validateDBConnection()