Connection pool for ldap

Question

Hi
My application is an interface to ldap directory. I have not used any ldap open source api to retrieve data from ldap. I have written connection pool that will help the application to connect to the ldap. It's working fine, but it's creating threads which are not invited.
ConnectionPool class takes care of the connection storage and creation, while Housekeeping thread relases these connection when idle after a given time.
Can someone please help in finding the problem in the code that creates additional threads.
package com.ba.cdLookup.manager;
import com.ba.cdLookup.exception.CDLookupException;
import com.ba.cdLookup.server.CdLookupProperties;
import java.util.Vector;
import javax.naming.Context;
import javax.naming.NamingException;
public class HouseKeeperThread extends Thread {
         * Apache Logger to log erro/info/debug statements.
    protected static org.apache.commons.logging.Log log = org.apache.axis.components.logger.LogFactory
         .getLog(HouseKeeperThread.class.getName());
    private static HouseKeeperThread houseKeeperThread;
         * Close all connections existing.
         * @param connections
         *                void
    private void closeConnections(Vector connections) {
     String methodIdentifier = "closeConnections";
     int numOfConn = connections.size();
     try {
         for (int i = 0; i < numOfConn; i++) {
          Context context = (Context) connections.get(i);
          if (context != null) {
              context.close();
              context = null;
              connections.remove(i);
              numOfConn--;
              log.info(" connection name:" + context
                   + " removed. Threadcount =" + (connections.size()));
     } catch (NamingException e) {
         String errMsg = "CDLdapBuilder connect() - failure while releasing connection "
              + " Exception is " + e.toString();
         log.error(errMsg);
     } catch (Exception e) {
         String errMsg = "CDLdapBuilder connect() - failure while releasing connection "
              + " Exception is " + e.toString();
         log.error(errMsg);
         * Thread run method
    public void run() {
     String methodIdentifier = "run";
     try {
         while(true){
          log.debug("house keeping :" + this + " ---sleep");
          //sleep(100000);
          log.debug("house keeping :" + this + " startd after sleep");
           sleep(CdLookupProperties.getHouseKeepConnectionTime());
          ConnectionPool connectionPool = ConnectionPool
               .getConnectionPool();
          Vector connList = connectionPool.getAvailableConnections();
          closeConnections(connList);
     } catch (CDLookupException cde) {
         log.error(methodIdentifier + " " + cde.getStackTrace());
     } catch (InterruptedException ie) {
         log.error(methodIdentifier + " " + ie.getStackTrace());
     * @param connectionPool
     * @return
     * Thread
    public static Thread getInstance() {
     if(houseKeeperThread==null){
         houseKeeperThread = new HouseKeeperThread();
     return houseKeeperThread ;
package com.ba.cdLookup.manager;
import com.ba.cdLookup.exception.CDLookupException;
import com.ba.cdLookup.server.CdLookupProperties;
import com.ba.cdwebservice.schema.cdLookupPacket.LookupFailureReasons;
import java.util.Properties;
import java.util.Vector;
import javax.naming.Context;
import javax.naming.NamingException;
import javax.naming.directory.DirContext;
import javax.naming.directory.InitialDirContext;
* ConnectionPool class manages, allocates LDAP connections. It works as a lazy
* binder and retrieves connections only when required. It doesn't allow
* connection greater then the maximum connection stated.
* To retrieve a connection the singelton method getConnectionPool is to used,
* which retruns thread safe singleton object for the connection.
public class ConnectionPool implements Runnable {
    private int initialConnections = 0;
    private int maxConnections = 0;
    private boolean waitIfBusy = false;
    private Vector availableConnections, busyConnections;
    private boolean connectionPending = false;
    private static int threadCount = 0;
         * classIdentifier
    private final String classIdentifier = "ConnectionPool";
         * Apache Logger to log erro/info/debug statements.
    protected static org.apache.commons.logging.Log log = org.apache.axis.components.logger.LogFactory
         .getLog(CDLdapBuilder.class.getName());
         * To get the attribute a systemaccessfor out of the search result
    private String vendorContextFactoryClass = "com.sun.jndi.ldap.LdapCtxFactory";// "com.ibm.jndi.LDAPCtxFactory";
         * context factory to use
    private String ldapServerUrl = "LDAP://test.ldap.com"; // default ldap
         * server live used by default
    private String searchBase;
         * environment properties.
    private Properties env;
         * DirContext
    private javax.naming.directory.DirContext ctx;
         * default search base to be used in Corporate Directory searches
    private String defaultSearchBase = "dc=Pathway";
         * search criteria
    private String searchAttributes;
         * search filter to retrieve data from CD
    private String searchFilter;
         * CorporateDirectoryLookup Constructor
         * <p>
         * loads the setup parameters from the properties file and stores them
         * Makes a connection to the directory and sets default search base
         * @throws CDLookupException
         * @throws CDLookupException
    private ConnectionPool() throws CDLookupException {
     this.maxConnections = CdLookupProperties.getMaxConnection();// maxConnections;
     this.initialConnections = CdLookupProperties.getInitialConnection();
     this.waitIfBusy = CdLookupProperties.isWaitIfBusy();
     this.searchBase = CdLookupProperties.getDefaultSearchBase();
     //for local env testing
//      this.maxConnections = 5;
//      this.initialConnections = 1;
//      this.waitIfBusy = true;
         * For keeping no of connections in the connection pool if
         * (initialConnections > maxConnections) { initialConnections =
         * maxConnections; }
     availableConnections = new Vector(maxConnections);
     busyConnections = new Vector(maxConnections);
     for (int i = 0; i < maxConnections; i++) {
         availableConnections.add(makeNewConnection());
         *  ConnectionPoolHolder provide Thread safe singleton
         *         instance of ConnectionPool class
    private static class ConnectionPoolHolder {
         * connection pool instance
     private static ConnectionPool connectionPool = null;
         * If no ConnectionPool object is present, it creates instance of
         * ConnectionPool class and initiates thread on that.
         * @return ConnectionPool Returns singleton object of ConnectionPool
         *         class.
         * @throws CDLookupException
     private static ConnectionPool getInstance() throws CDLookupException {
         if (connectionPool == null) {
          connectionPool = new ConnectionPool();
          new Thread(connectionPool).start();
          // Initiate house keeping thread.
          HouseKeeperThread.getInstance().start();
         return connectionPool;
         * Returns singleton object of ConnectionPool class.
         * @return ConnectionPool
         * @throws CDLookupException
    public static ConnectionPool getConnectionPool() throws CDLookupException {
     return ConnectionPoolHolder.getInstance();
         * getConnection retrieves connections to the corp directory. In case
         * there is no available connections in the pool then it'll try to
         * create one, if the max connection limit for the connection pool
         * reaches then this waits to retrieve one.
         * @return Context
         * @throws CDLookupException
    public synchronized Context getConnection() throws CDLookupException {
     String methodIdentifier = "getConnection";
     if (!availableConnections.isEmpty()) {
         int connectionSize = availableConnections.size() - 1;
         DirContext existingConnection = (DirContext) availableConnections
              .get(connectionSize);
         availableConnections.remove(connectionSize);
                 * If connection on available list is closed (e.g., it timed
                 * out), then remove it from available list and repeat the
                 * process of obtaining a connection. Also wake up threads that
                 * were waiting for a connection because maxConnection limit was
                 * reached.
         if (existingConnection == null) {
          notifyAll(); // Freed up a spot for anybody waiting
          return (getConnection());
         } else {
          busyConnections.add(existingConnection);
          return (existingConnection);
     } else {
                 * Three possible cases: 1) You haven't reached maxConnections
                 * limit. So establish one in the background if there isn't
                 * already one pending, then wait for the next available
                 * connection (whether or not it was the newly established one).
                 * 2) You reached maxConnections limit and waitIfBusy flag is
                 * false. Throw SQLException in such a case. 3) You reached
                 * maxConnections limit and waitIfBusy flag is true. Then do the
                 * same thing as in second part of step 1: wait for next
                 * available connection.
         if ((totalConnections() < maxConnections) && !connectionPending) {
          makeBackgroundConnection();
         } else if (!waitIfBusy) {
          throw new CDLookupException("Connection limit reached", 0);
                 * Wait for either a new connection to be established (if you
                 * called makeBackgroundConnection) or for an existing
                 * connection to be freed up.
         try {
          wait();
         } catch (InterruptedException ie) {
          String errMsg = "Exception raised =" + ie.getStackTrace();
          log.error(errMsg);
          throw new CDLookupException(classIdentifier, methodIdentifier,
               errMsg, ie);
         // connection freed up, so try again.
         return (getConnection());
         * You can't just make a new connection in the foreground when none are
         * available, since this can take several seconds with a slow network
         * connection. Instead, start a thread that establishes a new
         * connection, then wait. You get woken up either when the new
         * connection is established or if someone finishes with an existing
         * connection.
    private void makeBackgroundConnection() {
     connectionPending = true;
     try {
         Thread connectThread = new Thread(this);
         log.debug("background thread created");
         connectThread.start();
     } catch (OutOfMemoryError oome) {
         log.error("makeBackgroundConnection ="+ oome.getStackTrace());
         * Thread run method
    public void run() {
     String methodIdentifier = "run";
     try {
         Context connection = makeNewConnection();
         synchronized (this) {
          availableConnections.add(connection);
          connectionPending = false;
          notifyAll();
     } catch (Exception e) { // SQLException or OutOfMemory
         // Give up on new connection and wait for existing one
         // to free up.
         String errMsg = "Exception raised =" + e.getStackTrace();
         log.error(errMsg);   
         * This explicitly makes a new connection. Called in the foreground when
         * initializing the ConnectionPool, and called in the background when
         * running.
         * @return Context
         * @throws CDLookupException
    private Context makeNewConnection() throws CDLookupException {
     String methodIdentifier = "makeNewConnection";
     Context context = null;
     env = new Properties();
     log.debug("inside " + methodIdentifier);
     try {
         env.put(Context.INITIAL_CONTEXT_FACTORY,
              getVendorContextFactoryClass());
         env.put(Context.PROVIDER_URL, getLdapServerUrl());
         env.put("com.sun.jndi.ldap.connect.pool", "true");
         context = new InitialDirContext(env);
     } catch (NamingException e) {
         String errMsg = "CDLdapBuilder connect() - failure while attempting to contact "
              + ldapServerUrl + " Exception is " + e.toString();
         throw new CDLookupException(classIdentifier, methodIdentifier,
              errMsg, e, LookupFailureReasons.serviceUnavailable);
     } catch (Exception e) {
         String errMsg = "CDLdapBuilder connect() - failure while attempting to contact "
              + ldapServerUrl + " Exception is " + e.toString();
         throw new CDLookupException(classIdentifier, methodIdentifier,
              errMsg, e, LookupFailureReasons.serviceUnavailable);
     log.info("new connection :" + (threadCount++) + " name =" + context);
     log.debug("exit " + methodIdentifier);
     return context;
         * releases connection to the free pool
         * @param context
    public synchronized void free(Context context) {
     busyConnections.remove(context);
     availableConnections.add(context);
     // Wake up threads that are waiting for a connection
     notifyAll();
         * @return int give total no of avail connections.
    public synchronized int totalConnections() {
     return (availableConnections.size() + busyConnections.size());
         * Close all the connections. Use with caution: be sure no connections
         * are in use before calling. Note that you are not <I>required</I> to
         * call this when done with a ConnectionPool, since connections are
         * guaranteed to be closed when garbage collected. But this method gives
         * more control regarding when the connections are closed.
    public synchronized void closeAllConnections() {
     closeConnections(availableConnections);
     availableConnections = new Vector();
     closeConnections(busyConnections);
     busyConnections = new Vector();
         * Close all connections existing.
         * @param connections
         *                void
    private void closeConnections(Vector connections) {
     String methodIdentifier = "closeConnections";
     try {
         for (int i = 0; i < connections.size(); i++) {
          Context context = (Context) connections.get(i);
          if (context != null) {
              log.info(" connection name:" + context
                   + " removed. Threadcount =" + (threadCount++));
              context.close();
              context = null;
     } catch (NamingException e) {
         String errMsg = "CDLdapBuilder connect() - failure while attempting to contact "
              + ldapServerUrl + " Exception is " + e.toString();
         log.error(errMsg);
    public synchronized String toString() {
     String info = "ConnectionPool(" + getLdapServerUrl() + ","
          + getVendorContextFactoryClass() + ")" + ", available="
          + availableConnections.size() + ", busy="
          + busyConnections.size() + ", max=" + maxConnections;
     return (info);
         * @return the defaultSearchBase
    public final String getDefaultSearchBase() {
     return defaultSearchBase;
         * @param defaultSearchBase
         *                the defaultSearchBase to set
    public final void setDefaultSearchBase(String defaultSearchBase) {
     this.defaultSearchBase = defaultSearchBase;
         * @return the ldapServerUrl
    public final String getLdapServerUrl() {
     return ldapServerUrl;
         * @param ldapServerUrl
         *                the ldapServerUrl to set
    public final void setLdapServerUrl(String ldapServerUrl) {
     this.ldapServerUrl = ldapServerUrl;
         * @return the vendorContextFactoryClass
    public final String getVendorContextFactoryClass() {
     return vendorContextFactoryClass;
         * @param vendorContextFactoryClass
         *                the vendorContextFactoryClass to set
    public final void setVendorContextFactoryClass(
         String vendorContextFactoryClass) {
     this.vendorContextFactoryClass = vendorContextFactoryClass;
     * @return the availableConnections
    public final Vector getAvailableConnections() {
        return availableConnections;
}

Answer 1

Hi,
As the connection pool implmentation has the bug of not extending more than the min size, workaround I use is MIN_CONN=100 and MAX_CONN=101,and just waiting for the bug to get fixed. (using Netscape SDK for java4.0)