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

 */

import java.util.Vector;

import java.sql.*;

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

  private static int _incrConnNum;

  private static long _maxAge;

  private static long _maxConnTime;

  private static int _maxUsageNum;

  private static int _connCountWarnLimit;

  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 initConnNum = 0;

//		int incrConnNum = 0;

//		long maxAge = 0;

//		long maxConnTime = 0;

//		int maxUsageNum = 0;

//		int connCountWarnLevel = 0;

//		String dbConnRecyclThrd = null;

//		long cyclTimeDbConn = 0;

		try {

			// maximum connection number in the connection pool

					.getProperty("database.connectionCountWarnLimit"));

			_dbConnRecyclThrd = PropertyService

		} catch (PropertyNotFoundException pnfe) {

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

					+ pnfe.getMessage());

		}

		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

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

   * first time this method is called.

   */

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

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

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

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

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

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

      log.debug("DBConnectionPool.getInstance - 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("DBConnectionPool.getDBConnection - Tag: " + db.getTag());

//        logMetacat.debug("DBConnectionPool.getDBConnection - 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);

            logMetacat.debug("DBConnectionPool.getDBConnection - The method for checking is: " + db.getCheckOutMethodName());

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

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

            logMetacat.debug("DBConnectionPool.getDBConnection - The connection time is: " + db.getConnectionTime());

//            System.out.println("DBConnectionPool.getDBConnection - The method for checking is: " + db.getCheckOutMethodName());

//            System.out.println("DBConnectionPool.getDBConnection - The age is " + db.getAge());

//            System.out.println("DBConnectionPool.getDBConnection - The usage is " + db.getUsageCount());

//            System.out.println("DBConnectionPool.getDBConnection - The connection time is: " + db.getConnectionTime());

            db.setCheckOutTime(System.currentTimeMillis());

          }//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

           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" +

    		" open db connections is reached. New db connection to MetaCat" +

       		" cannot be established.");

       _countOfReachMaximum ++;

       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 )

    {

    }

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

    {

    }

    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 )

    {

//    		  " which have same tag to the returned DBConnetion object");

    }//if

    else

    {

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

//              conn.getCheckOutSerialNumber());

//      logMetacat.debug("DBConnectionPool.returnDBConnection - 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);

//        		dbConn.getTag() + " checked in.");

//        logMetacat.debug("DBConnectionPool.returnDBConnection - Connection: " +

//        		dbConn.getTag() + "'s status: " + dbConn.getStatus());

      {

//        		dbConn.getTag());

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

  {

    {

      runner.interrupt();

    }

    {

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

      {

        try

        {

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

          dbConn.close();

        }//try

        catch (SQLException e)

        {

      }//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)

            		(System.currentTimeMillis()-dbConn.getCheckOutTime())/1000 + " secs");

            logMetacat.fatal("DBConnectionPool.run - " + dbConn.getTag());

            logMetacat.error("DBConnectionPool.run - 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());

              System.out.println("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@Checking if the db connection " + dbConn.toString() + " is valid according to metacat.properties parameters.");

              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)

            {

            System.out.println("number of connections in pool: " + connectionPool.size());

            System.out.println("connection pool capacity: " + connectionPool.capacity());

        }//for

      }//synchronize

      {

      catch (Exception e)

      {

    }//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

	 * Print a list of busy connections. This method should be called when the

	 * used connection count exceeds the _connCountWarnLimit set in

	 * metacat.properties.

	 *

	 * @param usedConnectionCount

	 *            the current count of busy connections

	 */

	private static void printBusyDBConnections(int usedConnectionCount) {

		boolean showCountWarning = usedConnectionCount > _connCountWarnLimit;

		String warnMessage = "";

		// Check every DBConnection in the pool

		for (DBConnection dbConnection : connectionPool) {

			// check the status of db. If it is busy, add it to the message

			if (dbConnection.getStatus() == BUSY) {

				if (showCountWarning) {

					warnMessage += "\n   --- Method: " + dbConnection.getCheckOutMethodName() +

						" is using: " + dbConnection.getTag() + " for " + dbConnection.getAge() + " ms ";

				}

				if (dbConnection.getConnectionTime() > _maxConnTime) {

					logMetacat.warn("DBConnectionPool.printBusyDBConnections - Excessive connection time, method: " +

							dbConnection.getCheckOutMethodName() + " is using: " + dbConnection.getTag() +

							" for " + dbConnection.getConnectionTime() + " ms ");

				}

			}// if

		}// for

		if (showCountWarning) {

			logMetacat.warn("DBConnectionPool.printBusyDBConnections - " + usedConnectionCount +

					" DB connections currently busy because: " + warnMessage);

		}

	}

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

	 * value, shrink connection pool size to initial 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

     DBConnection conn = null; // the dbconnection

     freeConnectionSize = getFreeDBConnectionNumber();

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

    	 logMetacat.info("DBConnectionPool.shrinkConnectionPoolSize - 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)

        //remove it from pool

        connectionPool.remove(i);

     }//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