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

 *

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

import edu.ucsb.nceas.utilities.PropertyNotFoundException;

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

 */

  private static DBConnectionPool instance;

  private static Vector connectionPool;

  private static int initConnNum;

  private static int incrConnNum;

  private static long maxAge;

  private static long maxConnTime;

  private static int maxUsageNum;

  private static String dbConnRecyclThrd;

  private static long cyclTimeDbConn;

  final static int INITIALCONNECTIONNUMBER;

  final static int INCREASECONNECTIONNUMBER;

  final static long MAXIMUMAGE;

  final static long MAXIMUMCONNECTIONTIME;

  final static int MAXIMUMUSAGENUMBER;

  final static String DBCONNECTIONRECYCLETHREAD ;

  final static long CYCLETIMEOFDBCONNECTION;

  static {

		int maxConnNum = 0;

		int initConnNum = 0;

		int incrConnNum = 0;

		long maxAge = 0;

		long maxConnTime = 0;

		int maxUsageNum = 0;

		String dbConnRecyclThrd = null;

		long cyclTimeDbConn = 0;

		try {

			// maximum connection number in the connection pool

			maxConnNum = Integer.parseInt(PropertyService

					.getProperty("database.maximumConnections"));

			initConnNum = Integer.parseInt(PropertyService

					.getProperty("database.initialConnections"));

			incrConnNum = Integer.parseInt(PropertyService

					.getProperty("database.incrementConnections"));

			maxAge = Integer.parseInt(PropertyService

					.getProperty("database.maximumConnectionTime"));

			maxUsageNum = Integer.parseInt(PropertyService

					.getProperty("database.maximumUsageNumber"));

			dbConnRecyclThrd = PropertyService

					.getProperty("database.runDBConnectionRecycleThread");

			cyclTimeDbConn = Long.parseLong(PropertyService

					.getProperty("database.cycleTimeOfDBConnection"));

		} catch (PropertyNotFoundException pnfe) {

			System.err.println("Could not get property in static block: "

					+ pnfe.getMessage());

		}

		MAXIMUMCONNECTIONNUMBER = maxConnNum;

		INITIALCONNECTIONNUMBER = initConnNum;

		INCREASECONNECTIONNUMBER = incrConnNum;

		MAXIMUMAGE = maxAge;

		MAXIMUMCONNECTIONTIME = maxConnTime;

		MAXIMUMUSAGENUMBER = maxUsageNum;

		DBCONNECTIONRECYCLETHREAD  = dbConnRecyclThrd;

		CYCLETIMEOFDBCONNECTION = cyclTimeDbConn;

	}

  // the number for trying to check out a connection in the pool in

  // getDBConnection method

  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.

   */

      log.debug("Intial connection number: "+INITIALCONNECTIONNUMBER);

      log.debug("Increated connection Number: "+INCREASECONNECTIONNUMBER);

      log.debug("Maximum connection age: "+MAXIMUMAGE);

      log.debug("Maximum connection time: "+MAXIMUMCONNECTIONTIME);

      log.debug("Maximum usage count: "+MAXIMUMUSAGENUMBER);

      log.debug("Running recycle thread or not: "+DBCONNECTIONRECYCLETHREAD);

      log.debug("Cycle time of recycle: "+CYCLETIMEOFDBCONNECTION);

    return instance;

   */

    {

      runner = new Thread(this);

      runner.start();

    }

  /**

   * Method to get the size of DBConnectionPool

   */

  public int getSizeOfDBConnectionPool()

  {

    return connectionPool.size();

  }

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

    }

  /**

   * Method to get Connection object (Not DBConnection)

   */

  /*public static Connection getConnection() throws SQLException

  {

    DBConnection dbConn = null;

    //get a DBConnection

    dbConn = getDBConnection();

    //get connection object in DBConnection object

    //The following getConnections method is in DBConnection class

    return dbConn.getConnections();

  }*/

   * Method to get a DBConnection in connection pool

   * 1) try to get a DBConnection from DBConnection pool

   * 2) if 1) failed, then check the size of pool. If the size reach the

   *    maximum number of connection, throw a exception: couldn't get one

   * 3) If the size is less than the maximum number of connectio, create some

   *    new connections and recursive get one

   * @param methodName, the name of method which will check connection out

   */

  public static synchronized DBConnection getDBConnection(String methodName)

                                                throws SQLException

  {

      instance = DBConnectionPool.getInstance();

    }

    int index = 0; //index

    int size = 0; //size of connection pool

     //try every DBConnection in the pool

    //every DBConnection will be try LIMITE times

    for (int j=0 ; j<LIMIT; j++)

    {

       //create a random number as the started index for connection pool

      //So that the connection ofindex of 0 wouldn't be a the heaviest user

      random = (new Double (Math.random()*100)).intValue();

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

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

        logMetacat.debug("Tag: "+db.getTag());

        logMetacat.debug("Status: "+db.getStatus());

        if (db.getStatus()==FREE)

        {

          //If this connection is good, return this DBConnection

          if (validateDBConnection(db))

          {

            //set this DBConnection status

            db.setStatus(BUSY);

            db.increaseCheckOutSerialNumber(1);

            db.increaseUsageCount(1);

            //set method name to DBConnection

            db.setCheckOutMethodName(methodName);

                                       +db.getTag());

            logMetacat.debug("The method for checking is: "

                                              +db.getCheckOutMethodName());

            logMetacat.debug("The age is "+db.getAge());

            logMetacat.debug("The usage is "+db.getUsageCount());

            logMetacat.debug("The conection time it has: "

                                                +db.getConnectionTime());

            db.setCheckOutTime(System.currentTimeMillis());

            countOfReachMaximum =0;

          }//if

          else//The DBConnection has some problem

          {

            //close this DBConnection

            db.close();

            //remove it form connection pool

            db = new DBConnection();

        }//if

      }//for

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

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

    if ( size < 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

           DBConnection dbConn = new DBConnection();

           connectionPool.add(dbConn);

         }//for

       }//else

    }//if

    else

    {

                            " New db connection to MetaCat" +

                            " New db connection to MetaCat" +

       if (countOfReachMaximum >= 10)

         try

         {

         }

         catch (Exception e)

        {

      }

    //recursive to get new connection

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

  {

    if (dbConn.getUsageCount() >= MAXIMUMUSAGENUMBER )

    {

      dbConn.getUsageCount());

    }

    //Check if the DBConnection has too much connection time

    if (dbConn.getConnectionTime() >= MAXIMUMCONNECTIONTIME)

    {

      dbConn.getConnectionTime());

    }

    //Check if the DBConnection is too old

    if (dbConn.getAge() >=MAXIMUMAGE)

    {

    }

    //Try to run a simple query

    try

    {

      long startTime=System.currentTimeMillis();

      //increase one usagecount

      dbConn.increaseUsageCount(1);

      //increase connection time

      dbConn.setConnectionTime(stopTime-startTime);

    catch (Exception e)

    {

                                +e.getMessage());

    }

    return true;

  }//validateDBConnection()

   * Method to return a connection to DBConnection pool.

   * @param conn, the Connection object need to check in

   */

                                                              int serialNumber)

    int index = -1;

    DBConnection dbConn = null;

    index = getIndexOfPoolForConnection(conn);

    if ( index ==-1 )

    {

    }//if

    else

    {

      //if it is as same as the object's checkoutserial number.

      //if it is same return it. If it is not same, maybe the connection already

      // was returned ealier.

                                      +conn.getCheckOutSerialNumber());

      logMetacat.debug("serial number in local: "+serialNumber);

      {

        dbConn = (DBConnection) connectionPool.elementAt(index);

        //set status to free

        dbConn.setStatus(FREE);

        //count connection time

        dbConn.setConnectionTime

        dbConn.setCheckOutTime(0);

        logMetacat.debug("Connection: "+dbConn.getTag()+"'s status: "

                                                    +dbConn.getStatus());

      {

  }//returnConnection

  /**

   * Given a returned DBConnection, try to find the index of DBConnection object

   * in dbConnection pool by comparing DBConnection' tag and conn.toString.

   * If couldn't find , -1 will be returned.

   * @param conn, the connection need to be found

   */

  private static synchronized int getIndexOfPoolForConnection(DBConnection conn)

  {

    int index = -1;

    String info = null;

    if (conn==null)

    {

      return -1;

    }

    info = conn.getTag();

    //if the tag is null or empty, -1 will be returned

    if (info==null || info.equals(""))

    {

      return index;

    }

    //compare this info to the tag of every DBConnection in the pool

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

    {

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

      if (info.equals(dbConn.getTag()))

      {

        index = i;

        break;

      }//if

    }//for

    return index;

  }//getIndexOfPoolForConnection

  /**

   * Method to shut down all connections

   */

  public static void release()

  {

    //shut down the backgroud recycle thread

    {

      runner.interrupt();

    }

    synchronized(connectionPool)

    {

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

      {

        try

        {

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

          dbConn.close();

        }//try

        catch (SQLException e)

        {

                                            +e.getMessage());

      }//for

    }//synchronized

  }//release()

  /**

   * periodically to recycle the connection

   */

  public void run()

  {

    DBConnection dbConn = null;

    //keep the thread running

    while (true)

    {

      //check every dbconnection in the pool

      synchronized(connectionPool)

      {

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

        {

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

          //than 30000 milliseconds print it out

          if (dbConn.getStatus()==BUSY &&

            (System.currentTimeMillis()-dbConn.getCheckOutTime())>=30000)

            logMetacat.fatal(dbConn.getTag());

            logMetacat.error("method: "

                                          +dbConn.getCheckOutMethodName());

          }

          //check the validation of free connection in the pool

          {

            try

            {

              //try to print out the warning message for every connection

              {

                  +dbConn.getTag()+" : "+ dbConn.getWarningMessage());

              if (!validateDBConnection(dbConn))

              {

                dbConn.close();

                //remove it form connection pool

                connectionPool.remove(i);

                //insert a new DBConnection to same palace

                dbConn = new DBConnection();

                connectionPool.insertElementAt(dbConn, i);

            catch (SQLException e)

            {

                                              +e.getMessage());

          }//if

        }//for

      }//synchronize

      {

      catch (Exception e)

      {

                                              +e.getMessage());

    }//while

  }//run

   * Method to get the number of free DBConnection in DBConnection pool

   */

    int numberOfFreeDBConnetion = 0; //return number

    DBConnection db = null; //single DBconnection

    int poolSize = 0; //size of connection pool

    //get the size of DBConnection pool

    poolSize = connectionPool.size();

    //Check every DBConnection in the pool

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

    {

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

      //check the status of db. If it is free, count it

      if (db.getStatus() == FREE)

      {

        numberOfFreeDBConnetion++;

      }//if

    }//for

    //return the count result

    return numberOfFreeDBConnetion;

  }//getFreeDBConnectionNumber

   /**

   * Method to print out the method name which have busy DBconnection

   */

  public void printMethodNameHavingBusyDBConnection()

  {

    DBConnection db = null; //single DBconnection

    int poolSize = 0; //size of connection pool

    //get the size of DBConnection pool

    poolSize = connectionPool.size();

    //Check every DBConnection in the pool

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

    {

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

      //check the status of db. If it is free, count it

      if (db.getStatus() == BUSY)

      {

                                    +db.getCheckOutMethodName());

        logMetacat.warn("The busy DBConnection tag is: "

                                    +db.getTag());

    }//for

  }//printMethodNameHavingBusyDBConnection

   * Method to decrease dbconnection pool size when all dbconnections are idle

   * If all connections are free and connection pool size greater than

   * initial value, shrink connection pool size to intital value

   */

     int connectionPoolSize = 0; //store the number of dbconnection pool size

     int freeConnectionSize = 0; //store the number of free dbconnection in pool

     int difference = 0; // store the difference number between connection size

                         // and free connection

     boolean result = false; //result

     DBConnection conn = null; // the dbconnection

     freeConnectionSize = getFreeDBConnectionNumber();

                        "being used and connection pool size is " +connectionPoolSize);

    	 logMetacat.debug("Free Connection number: "+freeConnectionSize);

     //If all connections are free and connection pool size greater than

     //initial value, shrink connection pool size to intital value

     if (difference == 0 && connectionPoolSize > INITIALCONNECTIONNUMBER)

     {

       //intialConnectionnumber should be close and remove from pool

       for ( int i=connectionPoolSize-1; i >= INITIALCONNECTIONNUMBER ; i--)

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

         try

         {

         }//try

         catch (SQLException e)

           // set hadException ture

           hasException = true;

        //remove it from pool

        connectionPool.remove(i);

        // becuase enter the loop, set result true

        result = true;

     }//if

     //if hasException is true ( there at least once exception happend)

     // the result should be false

     if (hasException)

     {

       result =false;

     }//if

     // return result

     return result;

    /**

   * Method to decrease dbconnection pool size when all dbconnections are idle

   * If all connections are free and connection pool size greater than

   * initial value, shrink connection pool size to intital value

   */

  public static synchronized void shrinkDBConnectionPoolSize()

  {

     int connectionPoolSize = 0; //store the number of dbconnection pool size

     int freeConnectionSize = 0; //store the number of free dbconnection in pool

     int difference = 0; // store the difference number between connection size

                         // and free connection

     DBConnection conn = null; // the dbconnection

     connectionPoolSize = connectionPool.size();

     freeConnectionSize = getFreeDBConnectionNumber();

     difference = connectionPoolSize - freeConnectionSize;

     if(freeConnectionSize < connectionPoolSize){

         logMetacat.warn(difference + " connection(s) " +

                        "being used and connection pool size is " +connectionPoolSize);

     } else {