ConnectionManagerImpl.java

package org.objectweb.jonas.resource;

import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Set;
import java.util.Vector;

import javax.naming.Context;
import javax.naming.NamingException;
import javax.resource.ResourceException;
import javax.resource.spi.ConnectionEvent;
import javax.resource.spi.ConnectionEventListener;
import javax.resource.spi.ConnectionManager;
import javax.resource.spi.ConnectionRequestInfo;
import javax.resource.spi.ManagedConnection;
import javax.resource.spi.ManagedConnectionFactory;
import javax.resource.spi.ResourceAllocationException;
import javax.resource.spi.ValidatingManagedConnectionFactory;
import javax.security.auth.Subject;
import javax.transaction.RollbackException;
import javax.transaction.Transaction;
import javax.transaction.xa.XAResource;

import org.objectweb.jonas.resource.pool.api.Pool;
import org.objectweb.jonas.resource.pool.api.PoolMatchFactory;
import org.objectweb.jonas.resource.pool.lib.HArrayPool;
import org.objectweb.jotm.Current;
import org.objectweb.jotm.TransactionResourceManager;
import org.objectweb.transaction.jta.ResourceManagerEventListener;
import org.objectweb.transaction.jta.TransactionManager;
import org.objectweb.util.monolog.api.BasicLevel;
import org.objectweb.util.monolog.api.Logger;
import org.objectweb.util.monolog.api.LoggerFactory;
import org.objectweb.util.monolog.wrapper.printwriter.LoggerImpl;

public class ConnectionManagerImpl implements ConnectionEventListener, ConnectionManager,
                                              PoolMatchFactory, SQLManager,
                                              TransactionResourceManager {

    protected static Logger trace = null;
    protected static Logger poolTrace = null;

    protected ResourceManagerEventListener rmel = null;

    private String resourceBundleName = null;

    protected TransactionManager tm;

    protected Hashtable mc2mci = null;

    private int mcMaxPoolSize = -1;

    private int mcMinPoolSize = 0;

    private ManagedConnectionFactory mcf;
    private ValidatingManagedConnectionFactory vmcf = null;

    protected Pool poolMCs = null;

    protected Hashtable usedMCs = null;

    static final int MAX_PSTMT_SIZE = 10;

    private int maxPstmtPoolSize = MAX_PSTMT_SIZE;

    private int jdbcConnLevel = 0;
    private String jdbcConnTestStmt = "";

    protected Vector mcs = new Vector();

    protected Vector synchros = new Vector();

    private ResourceSpec rs = null;

    private String transSupport = null;

    public final static String RESOURCE_BUNDLE_NAME = "resourceBundleName";
    public final static String LOGGER = "org.objectweb.util.monolog.logger";
    public final static String POOL_LOGGER = "org.objectweb.util.monolog.logger_pool";
    public final static String LOGGER_FACTORY = "org.objectweb.util.monolog.loggerFactory";
    public final static String TRANSACTION_MANAGER = "transactionManager";
    public final static String RESOURCE_MANAGER_EVENT_LISTENER = "resourceManagerEventListener";
    public final static String RESOURCE_ADAPTER = "resourceAdapter";
    public final static String PRINT_WRITER = "printWriter";

    /*
     * These constants define the different transaction support values
     */
    public final static String NO_TRANS_SUPPORT = "NoTransaction";
    public final static String LOCAL_TRANS_SUPPORT = "LocalTransaction";
    public final static String XA_TRANS_SUPPORT = "XATransaction";

    public final static int PSWRAP_1 = 1;
    public final static int PSWRAP_2 = 2;
    public final static int PSWRAP_3 = 3;
    public final static int PSWRAP_4 = 4;
    public final static int PSWRAP_5 = 5;

    // JOTM variables
    private ManagedConnection jotmMc = null;
    private XAResource jotmXar = null;
    private String xaName = null;

    public ConnectionManagerImpl(String transSupport) {
        if (transSupport.length() == 0) {
            transSupport = NO_TRANS_SUPPORT;
        } else {
            this.transSupport = transSupport;
        }
    }

    public void setLogger(Logger l) {
        trace = l;
    }


    public void setLoggerFactory(LoggerFactory lf) {
        if (resourceBundleName == null) {
            trace = lf.getLogger("org.objectweb.resource.server");
        } else {
            trace = lf.getLogger("org.objectweb.resource.server");
            //,resourceBundleName);
        }
    }


    public void setPrintWriter(PrintWriter pw) {
        trace = new LoggerImpl(pw);
    }


    public void setResourceManagerEventListener(
            ResourceManagerEventListener rmel) {
        this.rmel = rmel;
    }


    public void setTransactionManager(TransactionManager tm) {
        this.tm = tm;
    }


    public void setResourceAdapter(ManagedConnectionFactory tmcf)
            throws Exception {
        setResourceAdapter(tmcf, new ConnectionManagerPoolParams());
    }

    public void setResourceAdapter(ManagedConnectionFactory tmcf,
                                   ConnectionManagerPoolParams cmpp)
            throws Exception {

        // set the max/min pool values
        if (cmpp.getPoolMax() != 0) {
            mcMaxPoolSize = cmpp.getPoolMax();
        }
        if (cmpp.getPoolMin() > 0) {
            mcMinPoolSize = cmpp.getPoolMin();
        }

        // set the jdbc connection info
        jdbcConnLevel = cmpp.getJdbcConnLevel();
        jdbcConnTestStmt = cmpp.getJdbcConnTestStmt();

        mcf = tmcf;
        if (mcf instanceof ValidatingManagedConnectionFactory) {
            vmcf = (ValidatingManagedConnectionFactory) mcf;
        }

        poolMCs = new HArrayPool(poolTrace);
        poolMCs.setMatchFactory(this);
        poolMCs.setMaxSize(mcMaxPoolSize);
        poolMCs.setMinSize(mcMinPoolSize);
        poolMCs.setInitSize(cmpp.getPoolInit());
        
        if (cmpp.getPoolMaxAge() > 0) {
            poolMCs.setMaxAge(cmpp.getPoolMaxAge());
        } else {
            long tAge = cmpp.getPoolMaxAgeMinutes()* 60L * 1000L;
            poolMCs.setMaxAge(tAge);
        }

        if (cmpp.getPoolMaxOpentime() > 0) {
            poolMCs.setMaxOpentime(cmpp.getPoolMaxOpentime());
        }
        poolMCs.setMaxWaiters(cmpp.getPoolMaxWaiters());
        poolMCs.setMaxWaitTime(cmpp.getPoolMaxWaittime());

        poolMCs.startMonitor();
        poolMCs.setSamplingPeriod(cmpp.getPoolSamplingPeriod());
        maxPstmtPoolSize = cmpp.getPstmtMax();

        usedMCs = new Hashtable();
        rs = new ResourceSpec(null, null);

        if (trace.isLoggable(BasicLevel.DEBUG)) {
            trace.log(BasicLevel.DEBUG, "");
        }
    }


    public void init(Context ctx) throws Exception {
        mc2mci = new Hashtable();

        // Get the resource bundle name to internationalise the log
        // Optional
        String resourceBundleName = null;
        try {
            resourceBundleName = (String) ctx.lookup(RESOURCE_BUNDLE_NAME);
        } catch (NamingException e) {
        }

        // Get the logger or the logger factory or the printwriter
        try {
            trace = (Logger) ctx.lookup(LOGGER);
            poolTrace = (Logger) ctx.lookup(POOL_LOGGER);
        } catch (NamingException e) {
        }
       
        if (trace == null) {
            try {
                setLoggerFactory((LoggerFactory) ctx.lookup(LOGGER_FACTORY));
            } catch (NamingException e2) {
            }
        }
        if (trace == null) {
            PrintWriter pw = null;
            try {
                pw = (PrintWriter) ctx.lookup(PRINT_WRITER);
            } catch (NamingException e3) {
            }
            setPrintWriter(pw);
        }

        if (!transSupport.equalsIgnoreCase(NO_TRANS_SUPPORT)) {
            // Get the transaction manager
            tm = (TransactionManager) ctx.lookup(TRANSACTION_MANAGER);
        }

        // Get the set of connection
        try {
            rmel = (ResourceManagerEventListener)
                    ctx.lookup(RESOURCE_MANAGER_EVENT_LISTENER);
        } catch (NamingException ne) {
        }

        // Get the managedConnectionFactory instance which represents the resource
        // adapter
        try {
            setResourceAdapter(
                    (ManagedConnectionFactory) ctx.lookup(RESOURCE_ADAPTER));
        } catch (NamingException ne) {
        }
    }


    public void cleanResourceAdapter() throws ResourceException {
        // Delete the PreparedStatements
        PreparedStatementWrapper pw = null;
        while (mcs != null && mcs.size() > 0) {
            MCInfo mci = (MCInfo) mcs.remove(0);
            mci.usedCs.clear();
            synchronized (mci.pStmts) {
                // Remove the PreparedStatements on the MC
                while (mci.pStmts != null && mci.pStmts.size() > 0) {
                    pw = (PreparedStatementWrapper) mci.pStmts.remove(0);
                    try {
                        pw.destroy();
                    } catch (Exception ex) {
                    }
                }
            }
            try {
                mc2mci.remove(mci.mc);
                mci.mc.destroy();
            } catch (Exception ex) {
            }
        }
        if (usedMCs != null) {
            for (Enumeration en = usedMCs.keys(); en.hasMoreElements();) {
                Transaction tx = (Transaction) en.nextElement();
                MCInfo mci = (MCInfo) usedMCs.get(tx);
                if (mci == null) {
                    continue;
                }
                if (mci.rmeCalled) {
                    mci.rme.isValid = false;
                    rmel.connectionClosed(mci.rme);
                    mci.rmeCalled = false;
                }
                mci.usedCs.clear();
                // Remove the PreparedStatements on the MC
                synchronized (mci.pStmts) {
                    while (mci.pStmts != null && mci.pStmts.size() > 0) {
                        pw = (PreparedStatementWrapper) mci.pStmts.remove(0);
                        try {
                            pw.destroy();
                        } catch (Exception ex) {
                        }
                    }
                }
                try {
                    mc2mci.remove(mci.mc);
                    mci.mc.destroy();
                } catch (Exception ex) {
                }
            }
        }
        while (synchros != null && synchros.size() > 0) {
            MCInfo mci = (MCInfo) synchros.remove(0);
            mci.usedCs.clear();
            // Remove the PreparedStatements on the MC
            synchronized (mci.pStmts) {
                while (mci.pStmts != null && mci.pStmts.size() > 0) {
                    pw = (PreparedStatementWrapper) mci.pStmts.remove(0);
                    try {
                        pw.destroy();
                    } catch (Exception ex) {
                    }
                }
            }
            try {
                mc2mci.remove(mci.mc);
                mci.mc.destroy();
            } catch (Exception ex) {
            }
        }
    }


    public synchronized Object allocateConnection(
            ManagedConnectionFactory pMcf, ConnectionRequestInfo cxRequestInfo)
            throws ResourceException {

        MCInfo mci = null;
        Transaction currentTx = null;
        Object connection = null;
        int retries = 0;
        Subject subject = null;

        while (connection == null && retries < 20) {
            if (mcf != pMcf) {
                throw new ResourceException(
                        "This ConnectionManager doesn't manage this RA:" + mcf);
            }

            currentTx = null;
            try {
                if (tm != null) {
                    currentTx = tm.getTransaction();
                }
            } catch (Exception e) {
                trace.log(BasicLevel.ERROR,
                        "Impossible to get the current transaction", e,
                        "ConnectionManagerImpl", "allocateConnection");
            }

            //if there is a transaction check if a MC is already associated
            mci = (currentTx == null ? null : (MCInfo) usedMCs.get(currentTx));
            if (mci != null) {
                if (mci.mc != null) {
                    // There are connections, try to match with the
                    // ManagedConnectionFactory
                    trace.log(BasicLevel.DEBUG, "MC (" + mci.mc + ") associated to the current Tx (" + currentTx + ") found");
                    Set s = new HashSet();
                    s.add(mci.mc);
                    if (mci.mc != mcf.matchManagedConnections(s, null, cxRequestInfo)) {
                        throw new ResourceException(
                                "ConnectionManagerImpl.allocateConnection: illegal state : no mc is matched by mcf");
                    }
                    trace.log(BasicLevel.DEBUG, "XA Resource " + mci.getXAResource()
                                                + " is already enlisted in Tx:" + mci.ctx);
                } else {
                    // This connection occurred an error before
                    trace.log(BasicLevel.INFO, "remnant of an old failed connection");
                    mci.ctx = null;
                    mci = null;
                    usedMCs.remove(currentTx);
                }
            }

            if (mci == null) {
                // No managed connection found => get a free ManagedConnection
                // from the right pool

                //ri.rs.subject = null; // Never set => already at null
                rs.cxRequestInfo = cxRequestInfo;
                if (subject == null && cxRequestInfo != null) {
                    // Create a subject to pass on
                }
                try {
                    ManagedConnection mc = (ManagedConnection) poolMCs.getResource(rs);
                    if (mc == null) {
                        throw new ResourceException("ConnectionManagerImpl.allocateConnection: cannot allocate a ManagedConnection");
                    }
                    mci = (MCInfo) mc2mci.get(mc);
                    if (mci == null) {
                        mci = new MCInfo(mc);
                        mc2mci.put(mc, mci);
                    }
                    trace.log(BasicLevel.DEBUG, "get a MC from the ra pool, mc=" + mci.mc);
                    if (transSupport.equalsIgnoreCase(LOCAL_TRANS_SUPPORT)) {
                        if (mci.lw == null) {
                            mci.lw = new LocalXAWrapper(mci.mc.getLocalTransaction(), trace);
                        }
                    } else if (mci.lw != null) {
                        mci.lw = null;
                    }
                    if (!mci.connectionEventListener) {
                        mci.mc.addConnectionEventListener(this);
                        mci.connectionEventListener = true;
                    }
                    mci.synchro = null;
                    // If a global transaction is already started then enlist the
                    // ManagedConnection instance
                    if (currentTx != null) {
                        trace.log(BasicLevel.DEBUG, "Enlist the XA Resource "
                                                    + mci.getXAResource() + " in Tx:"
                                                    + currentTx);
                        currentTx.enlistResource(mci.getXAResource());
                        usedMCs.put(currentTx, mci);
                        mci.ctx = currentTx;
                    } else {
                        // There are not Transaction at the moment but the user can
                        // start a transaction after the getConnection call.
                        mci.ctx = null;
                        // must be clean
                        mcs.add(mci);
                        mci.rme = new RMEImpl(mci, trace);
                        trace.log(BasicLevel.DEBUG, "Register the managed connection (no tx)");
                        // Always put in list, fix bug on connection late enlistment
                        if (!mci.rmeCalled) {
                            mci.rme.isValid = true;
                            rmel.connectionOpened(mci.rme);
                            mci.rmeCalled = true;
                        }
                    }
                } catch (ResourceException re) {
                    trace.log(BasicLevel.ERROR, re.getMessage(), re);
                    throw re;
                } catch (Exception e) {
                    ResourceException re = new ResourceException("ResourceService : an error related allocation of ManagedConnection ");
                    re.initCause(e);
                    trace.log(BasicLevel.ERROR, re.getMessage(), e);
                    throw re;
                }

            }

            //Fetch a free Connection from the ManagedConnection
            connection = mci.mc.getConnection(null, cxRequestInfo);
            // Want to add the non-wrapped Connection object
            mci.usedCs.add(connection);
            if (connection instanceof java.sql.Connection) {
                try {
                    // Need a wrapper for non JOnAS jdbc ConnectionImpl
                    if (connection instanceof org.objectweb.jonas.jdbc.ConnectionImpl) {
                        ((org.objectweb.jonas.jdbc.ConnectionImpl) connection).setJonasInfo(mci, this);
                    } else {
                        connection = JonasSQLWrapper.createSQLWrapper(connection, mci, this, trace);
                    }
                    // Check the connection before reusing it
                    if (jdbcConnLevel > 0) {
                        try {
                            if (trace.isLoggable(BasicLevel.DEBUG)) {
                                trace.log(BasicLevel.DEBUG, "Check the JDBC connection");
                            }
                            boolean isClosed = true;
                            // Used for logical testing of connection
                            if (connection instanceof org.objectweb.jonas.jdbc.ConnectionImpl) {
                                isClosed = ((org.objectweb.jonas.jdbc.ConnectionImpl) connection).isPhysicallyClosed();
                            } else {
                                isClosed = ((Connection) connection).isClosed();
                            }
                            if (isClosed) {
                                connectionErrorOccurred(new ConnectionEvent(mci.mc,
                                        ConnectionEvent.CONNECTION_ERROR_OCCURRED));
                                connection = null;
                                retries++;
                                continue;
                            }
                            if (jdbcConnLevel > 1 && jdbcConnTestStmt != null
                                    && jdbcConnTestStmt.length() > 0) {
                                if (trace.isLoggable(BasicLevel.DEBUG)) {
                                    trace.log(BasicLevel.DEBUG, "retrying connection: " + jdbcConnTestStmt);
                                }
                                java.sql.Statement stmt = ((Connection) connection).createStatement();
                                stmt.execute(jdbcConnTestStmt);
                                stmt.close();
                            }
                        } catch (Exception e) {
                            trace.log(BasicLevel.ERROR, "Error on connection: removing invalid managed connection " + mci.mc + ": ", e);
                            connectionErrorOccurred(new ConnectionEvent(mci.mc,
                                    ConnectionEvent.CONNECTION_ERROR_OCCURRED));
                            connection = null;
                            retries++;
                            continue;
                        }
                    }
                } catch (Exception ex) {
                    trace.log(BasicLevel.ERROR, ex.getMessage(), ex);
                    throw new ResourceException(ex.getMessage());
                }
            }

        }
        trace.log(BasicLevel.DEBUG, "get a logical connection on MC:" + connection);

        if (connection == null) {
            if (retries > 0) {
                throw new ResourceAllocationException(
                        "Unable to obtain a connection object.  Check the validity of the jdbc-test-statement");
            } else {
                throw new ResourceAllocationException("Unable to obtain a connection object");
            }
        }

        return connection;
    }


    public boolean matchResource(Object res, Object hints) {
        return true;
    }

    public Object matchResource(Set res, Object hints) throws Exception {
        ResourceSpec spec = (hints != null) ? (ResourceSpec) hints : new ResourceSpec(null, null);
        return mcf.matchManagedConnections(res, null, spec.cxRequestInfo);
    }


    public Object createResource(Object hints) throws Exception {
        ResourceSpec spec = (hints != null) ? (ResourceSpec) hints : new ResourceSpec(null, null);
        ManagedConnection mc = mcf.createManagedConnection(spec.subject,
                spec.cxRequestInfo);
        trace.log(BasicLevel.DEBUG, "Created MC: " + mc);
        return mc;
    }

    public void validateResource(Set res) throws Exception {
        if (vmcf == null) {
            return;
        }
        try {
            Set invMcs = vmcf.getInvalidConnections(res);
            Iterator it = invMcs.iterator();
            while (it.hasNext()) {
                Object obj = it.next();
                poolMCs.releaseResource(obj, true, true);
            }
        } catch (Exception ex) {
            trace.log(BasicLevel.DEBUG, "Error trying to validate Connections for " + mcf);
        }
    }


    public PreparedStatement getPStatement(MCInfo mcinfo, Object conn, String user, String sql)
            throws SQLException {
        return getPStatement(mcinfo, conn, user, sql, ResultSet.TYPE_FORWARD_ONLY,
                             ResultSet.CONCUR_READ_ONLY, -1, -1, null, null, PSWRAP_1);

    }

    public PreparedStatement getPStatement(MCInfo mcinfo, Object conn, String user, String sql,
                                           int resultSetType, int resultSetConcurrency)
            throws SQLException {
        return getPStatement(mcinfo, conn, user, sql, resultSetType, resultSetConcurrency,
                             -1, -1, null, null, PSWRAP_1);
    }

    // JDBC 3.0
    public PreparedStatement getPStatement(MCInfo mcinfo,
                                           Object conn,
                                           String user, String sql,
                                           int resultSetType,
                                           int resultSetConcurrency,
                                           int resultSetHoldability)
            throws SQLException {
              return getPStatement(mcinfo, conn, user, sql, resultSetType, resultSetConcurrency,
                      resultSetHoldability, -1, null, null, PSWRAP_2);
    }

    // JDBC 3.0
    public PreparedStatement getPStatement(MCInfo mcinfo,
                                           Object conn,
                                           String user, String sql,
                                           int autoGeneratedKeys)
            throws SQLException {
                return getPStatement(mcinfo, conn, user, sql, -1, -1, -1,
                        autoGeneratedKeys, null, null, PSWRAP_3);
    }

    // JDBC 3.0
    public PreparedStatement getPStatement(MCInfo mcinfo,
                                           Object conn,
                                           String user, String sql,
                                           int[] columnIndexes)
            throws SQLException {
              return getPStatement(mcinfo, conn, user, sql, -1, -1, -1, -1,
                      columnIndexes, null, PSWRAP_4);
    }

    // JDBC 3.0
    public PreparedStatement getPStatement(MCInfo mcinfo,
                                           Object conn,
                                           String user, String sql,
                                           String[] columnNames)
            throws SQLException {
              return getPStatement(mcinfo, conn, user, sql, -1, -1, -1, -1,
                      null, columnNames, PSWRAP_5);
    }


    private PreparedStatement getPStatement(MCInfo mcinfo,
                                            Object conn,
                                            String user,
                                            String sql,
                                            int resultSetType,
                                            int resultSetConcurrency,
                                            int resultSetHoldability,
                                            int autoGeneratedKeys,
                                            int [] columnIndexes,
                                            String [] columnNames,
                                            int pswrapType)
            throws SQLException {

        trace.log(BasicLevel.DEBUG, "Sql: " + sql + " User: " + user);
        // Use for the equals test
        PreparedStatementWrapper psw = null;
        switch (pswrapType) {
            case PSWRAP_1:
                psw = new PreparedStatementWrapper(user, sql,
                                                   resultSetType,
                                                   resultSetConcurrency,
                                                   trace);
                break;
            case PSWRAP_2:
                psw = new PreparedStatementWrapper(user, sql,
                                                   resultSetType,
                                                   resultSetConcurrency,
                                                   resultSetHoldability,
                                                   trace);
                break;
            case PSWRAP_3:
                psw = new PreparedStatementWrapper(user, sql,
                                                   autoGeneratedKeys,
                                                   trace);
                break;
            case PSWRAP_4:
                psw = new PreparedStatementWrapper(user, sql,
                                                   columnIndexes,
                                                   trace);
                break;
            case PSWRAP_5:
                psw = new PreparedStatementWrapper(user, sql,
                                                   columnNames,
                                                   trace);
                break;
            default:
                break;
        }

        synchronized (mcinfo.pStmts) {
            trace.log(BasicLevel.DEBUG, "MC pStmts: " + mcinfo.pStmts);
            //Check if statement matches ManagedConnection list & valid
            for (int i = 0; i < mcinfo.pStmts.size(); i++) {
                if (mcinfo.pStmts.get(i).equals(psw)) {
                    PreparedStatementWrapper ps = (PreparedStatementWrapper) mcinfo.pStmts.remove(i);
                    ps.clearPstmtValues();
                    mcinfo.pStmts.add(ps);  // add last
                    mcinfo.stmtHash.add(ps);
                    return ps;
                }
            }

            //If not in either, call con.prepareStatement, wrap the returned one
            // and add it to MC pool
            PreparedStatement ps = null;
            switch (pswrapType) {
                case PSWRAP_1:
                    ps = ((java.sql.Connection) conn).
                           prepareStatement(sql, resultSetType, resultSetConcurrency);
                    break;
                case PSWRAP_2:
                    ps = ((java.sql.Connection) conn).
                           prepareStatement(sql, resultSetType, resultSetConcurrency,
                                            resultSetHoldability);
                    break;
                case PSWRAP_3:
                    ps = ((java.sql.Connection) conn).
                           prepareStatement(sql, autoGeneratedKeys);
                    break;
                case PSWRAP_4:
                    ps = ((java.sql.Connection) conn).
                           prepareStatement(sql, columnIndexes);
                    break;
                case PSWRAP_5:
                    ps = ((java.sql.Connection) conn).
                           prepareStatement(sql, columnNames);
                    break;
                default:
                    break;
            }
            if (maxPstmtPoolSize < 0) {
                // No prepared statement pool
                trace.log(BasicLevel.DEBUG, "Pooling is disabled");
                return ps;
            } else if (maxPstmtPoolSize == 0 || mcinfo.pStmts.size() < maxPstmtPoolSize) {
                psw.setPreparedStatement(ps);
                mcinfo.pStmts.add(psw);
                mcinfo.stmtHash.add(ps);
                trace.log(BasicLevel.DEBUG, "Adding PStmt: " + psw);
                return psw;
            } else if (mcinfo.isFreeStmt()) {
                // Remove an entry from the current pool
                PreparedStatementWrapper pw = (PreparedStatementWrapper) mcinfo.pStmts.remove(0);
                pw.destroy();
                psw.setPreparedStatement(ps);
                mcinfo.pStmts.add(psw);
                mcinfo.stmtHash.add(ps);
                trace.log(BasicLevel.DEBUG, "Replacing " + pw + " with " + psw);
                return psw;
            } else {
                // No room for the Wrapped statement just return the PreparedStatement
                trace.log(BasicLevel.DEBUG, "No room in pool");
                return ps;
            }
        }
    }


    public void releaseResource(Object rMc) throws Exception {
        trace.log(BasicLevel.DEBUG, "MC: " + rMc);
        if (rMc instanceof ManagedConnection) {
            ManagedConnection mc = (ManagedConnection) rMc;
            MCInfo mcinfo = (MCInfo) mc2mci.remove(mc);
            if (mcinfo != null) {
                destroyPStmts(mcinfo);
            }
        }
    }

    public void destroyPStmts(MCInfo mcinfo) throws Exception {
        trace.log(BasicLevel.DEBUG, "MCInfo: " + mcinfo);
        synchronized (mcinfo.pStmts) {
            if (mcinfo.pStmts.size() <= 0) {
                return;
            }
            int stmtSize = mcinfo.pStmts.size();
            try {
                for (int i = 0; i < stmtSize; i++) {
                    PreparedStatementWrapper psw = (PreparedStatementWrapper)
                            mcinfo.pStmts.remove(0);
                    psw.closePstmt();
                }
            } catch (Exception ex) {
                throw ex;
            }
        }
    }

    public synchronized void connectionClosed(ConnectionEvent event) {
        ManagedConnection mc = (ManagedConnection) event.getSource();
        if (mc == null) {
            trace.log(BasicLevel.ERROR, "no mc found in Event!");
        }

        MCInfo mci = (MCInfo) mc2mci.get(mc);
        if (mci == null) {
            trace.log(BasicLevel.ERROR, "no mci found!");
            return;
        }

        if (poolTrace.isLoggable(BasicLevel.DEBUG)) {
            poolTrace.log(BasicLevel.DEBUG, "enter\n" + getState("\t"));
        }

        mci.usedCs.remove(event.getConnectionHandle());

        if (mci.usedCs.isEmpty()) {
            trace.log(BasicLevel.DEBUG, "Last Connection has just been removed");

            try {
                Transaction currentTx = null;
                if (tm != null) {
                    currentTx = tm.getTransaction();
                }

                if (mci.localTransaction && currentTx == null) {
                    trace.log(BasicLevel.ERROR, "The managed connection is being closed while a localtransaction is not finished");
                }

                if (currentTx != null) {
                    mci.ctx = currentTx;

                    if (mci.synchro == null) {
                        try {
                            currentTx.registerSynchronization(
                                    new MySynchro(this, mci));
                            trace.log(BasicLevel.DEBUG, "registerSynchro mc=" + mci.mc);
                        } catch (RollbackException e) {
                            // The transaction has been marked as rollbackOnly
                            // but the synchronization is registered.
                            trace.log(BasicLevel.INFO, "registerSynchronization on transaction marked as Rollback only, mc=" + mci.mc);
                        }
                    }
                } else if (mci.localTransaction) {
                    trace.log(BasicLevel.DEBUG, "MC isn't released because local transaction is not finished");

                } else {
                    trace.log(BasicLevel.DEBUG, "no currentTx");

                    mcs.remove(mci);

                    if (mci.ctx != null) {
                        usedMCs.remove(mci.ctx);
                        mci.ctx = null;
                    }

                    mci.mc.cleanup();

                    // Free up the PreparedStatements
                    mci.stmtHash.clear();

                    // Release the MC from its pool
                    poolMCs.releaseResource(mci.mc, false, true);

                }
                if (mci.rmeCalled) {
                    //Signal to the RessourceManagerEventListener mc is released
                    mci.rme.isValid = false;
                    rmel.connectionClosed(mci.rme);
                    mci.rmeCalled = false;
                }
            } catch (Exception e) {
                trace.log(BasicLevel.ERROR,
                        "an error during delisting of ManagedConection: ", e);
            }
            if (poolTrace.isLoggable(BasicLevel.DEBUG)) {
                poolTrace.log(BasicLevel.DEBUG, "exit\n" + getState("\t"));
            }
        }
    }


    public void connectionErrorOccurred(ConnectionEvent event) {
        ManagedConnection mc = (ManagedConnection) event.getSource();
        if (mc == null) {
            trace.log(BasicLevel.ERROR, "no mc found in Event!");
        }

        MCInfo mci = (MCInfo) mc2mci.get(mc);
        if (mci == null) {
            trace.log(BasicLevel.ERROR, "no mci found!");
            return;
        }

        if (poolTrace.isLoggable(BasicLevel.DEBUG)) {
            poolTrace.log(BasicLevel.DEBUG, "enter\n" + getState("\t"));
        }

        mci.usedCs.clear();

        try {
            if (mci.rmeCalled) {
                //Signal to the RessourceManagerEventListener mc is released
                mci.rme.isValid = false;
                rmel.connectionErrorOccured(mci.rme);
                mci.rmeCalled = false;
            }
            // Detach the connectionManager from the mc
            mc.removeConnectionEventListener(this);
            // Remove the association (transaction ctx / mc)
            if (mci.ctx != null) {
                usedMCs.remove(mci.ctx);
                mci.ctx = null;
            } else {
                mcs.remove(mci);
            }

            trace.log(BasicLevel.DEBUG, "Destroying managed connection (" + mc + ")");
            // Destroy the PreparedStatements
            destroyPStmts(mci);

            poolMCs.releaseResource(mc, true, false);
            if (poolTrace.isLoggable(BasicLevel.DEBUG)) {
                poolTrace.log(BasicLevel.DEBUG, "enter\n" + getState("\t"));
            }
            
            mc2mci.remove(mc);

        } catch (Exception e) {
            trace.log(BasicLevel.ERROR,
                    "an error related during delisting of ManagedConection");
        }
    }


    public void localTransactionCommitted(ConnectionEvent event) {
        ManagedConnection mc = (ManagedConnection) event.getSource();
        if (mc == null) {
            trace.log(BasicLevel.ERROR, "no mc found in Event!");
        }

        MCInfo mci = (MCInfo) mc2mci.get(mc);
        if (mci == null) {
            trace.log(BasicLevel.ERROR, "no mci found!");
            return;
        }
        mci.localTransaction = false;

        if (mci.usedCs.isEmpty()) {
            trace.log(BasicLevel.DEBUG, "Close the managed connection");

            if (mci.rmeCalled) {
                //Signal to the RessourceManagerEventListener mc is released
                mci.rme.isValid = false;
                rmel.connectionClosed(mci.rme);
                mci.rmeCalled = false;
            }

            if (mci.synchro == null) {
                mcs.remove(mci);
                if (mci.ctx != null) {
                    usedMCs.remove(mci.ctx);
                    mci.ctx = null;
                }

                try {
                    mci.mc.cleanup();

                    // Free up the PreparedStatements
                    mci.stmtHash.clear();

                    // Release the MC from its pool
                    poolMCs.releaseResource(mci.mc, false, true);
                } catch (Exception e) {
                    trace.log(BasicLevel.ERROR,
                            "an error related ManagedConection release",
                            e, "ConnectionManagerImpl", "localTransactionCommitted");
                }
            }
        }
    }


    public void localTransactionRolledback(ConnectionEvent event) {
        ManagedConnection mc = (ManagedConnection) event.getSource();
        if (mc == null) {
            trace.log(BasicLevel.ERROR, "no mc found in Event!");
        }

        MCInfo mci = (MCInfo) mc2mci.get(mc);
        if (mci == null) {
            trace.log(BasicLevel.ERROR, "no mci found!");
            return;
        }
        mci.localTransaction = false;

        if (mci.usedCs.isEmpty()) {
            trace.log(BasicLevel.DEBUG, "Close the managed connection");

            if (mci.rmeCalled) {
                //Signal to the ResourceManagerEventListener mc is released
                mci.rme.isValid = false;
                rmel.connectionClosed(mci.rme);
                mci.rmeCalled = false;
            }

            if (mci.synchro == null) {
                mcs.remove(mci);
                if (mci.ctx != null) {
                    usedMCs.remove(mci.ctx);
                    mci.ctx = null;
                }

                try {
                    mci.mc.cleanup();

                    // Free up the PreparedStatements
                    mci.stmtHash.clear();

                    // Release the MC from its pool
                    poolMCs.releaseResource(mci.mc, false, true);
                } catch (Exception e) {
                    trace.log(BasicLevel.ERROR,
                            "an error related during ManagedConection release:",
                            e, "ConnectionManagerImpl", "localTransactionRolledback");
                }
            }
        }
    }


    public void localTransactionStarted(ConnectionEvent event) {
        ManagedConnection mc = (ManagedConnection) event.getSource();
        if (mc == null) {
            trace.log(BasicLevel.ERROR, "no mc found in Event!");
        }

        MCInfo mci = (MCInfo) mc2mci.get(mc);
        if (mci == null) {
            trace.log(BasicLevel.ERROR, "no mci found!");
            return;
        }
        mci.localTransaction = true;
    }


    public String toString() {
        String m = super.toString();
        // remove package name
        int c1 = 0;
        int current = m.indexOf(".");
        while (current != -1) {
            c1 = current;
            current = m.indexOf(".", current + 1);
        }
        return m.substring(c1 + 1, m.length());
    }


    protected String getState(String prefix) {
        String res = prefix + "mcf=" + mcf + "\n";
        res += prefix + "ResourceSpec=" + rs.toString() + "\n";
        res += prefix + "size of MC pool:" + poolMCs.getSize() + "\n";
        res += prefix + "size of usedMCs:" + usedMCs.size() + "\n";
        res += prefix + "mcs attached to a tx:\n";
        for (Enumeration en = usedMCs.keys(); en.hasMoreElements();) {
            Object tx = en.nextElement();
            MCInfo mci = (MCInfo) usedMCs.get(tx);
            res += prefix + "MCI : tx=" + tx + "\n";
            res += mci.getState(prefix + "\t");
        }
        res += prefix + "mcs not attached to a tx:\n";
        for (Enumeration en = mcs.elements(); en.hasMoreElements();) {
            MCInfo mci = (MCInfo) en.nextElement();
            res += mci.getState(prefix + "\t");
        }
        res += prefix + "mcs waiting for tx commit or rollback:\n";
        for (Enumeration en = synchros.elements(); en.hasMoreElements();) {
            MCInfo mci = (MCInfo) en.nextElement();
            res += mci.getState(prefix + "\t");
        }
        return res;
    }

    public void setXAName(String xanm) {
        xaName = xanm;
    }

    public String getXAName() {
        return (xaName);
    }

    public void registerXAResource() {
        // If no RM or the RAR doesn't support XA, then just return
        if (tm == null) {
            return;
        }
        if (!transSupport.equalsIgnoreCase(XA_TRANS_SUPPORT)) {
            return;
        }

        // Find an entry in free pool
        // If none, then create one
        MCInfo mci = null;
        XAResource xar = null;
        try {
            ManagedConnection mc = (ManagedConnection) poolMCs.getResource(rs);
            if (mc == null) {
                trace.log(BasicLevel.DEBUG, "Cannot allocate a ManagedConnection for registerXAResource");
                return;
            }

            mci = (MCInfo) mc2mci.get(mc);
            if (mci == null) {
                mci = new MCInfo(mc);
                mc2mci.put(mc, mci);
            }

            xar = mc.getXAResource();
            trace.log(BasicLevel.DEBUG, "got a MC from the ra pool, mc=" + mci.mc
                                        + " xar=" + xar);

            if (!mci.connectionEventListener) {
                mci.mc.addConnectionEventListener(this);
                mci.connectionEventListener = true;
            }

            mci.synchro = null;

        } catch (ResourceException re) {
            return;
        } catch (Exception e) {
            trace.log(BasicLevel.ERROR, e.getMessage(), e);
            return;
        }

        // Setup globals so it can be returned to the pool
        jotmMc = mci.mc;
        jotmXar = xar;

        // Call to register it
        try {
            trace.log(BasicLevel.INFO, "Registering name = " + xaName + " xar = " + jotmXar);
            ((Current) tm).getTransactionRecovery().registerResourceManager(xaName, jotmXar, "", this);
       } catch (Exception ex) {
            trace.log(BasicLevel.ERROR, ex.getMessage(), ex);
            returnXAResource(xaName, jotmXar);
        }
    }

    public void returnXAResource(String rmName, XAResource rmXares) {
        // Get the associated MC
        // Clean it up and return it to the free pool
        trace.log(BasicLevel.INFO, "Removing name = " + xaName + " xar = " + jotmXar);
        if (jotmXar == null) {
            return;
        }
        if (!rmXares.equals(jotmXar)) {
            trace.log(BasicLevel.ERROR, "XAResource of " + rmXares + " and "
                                        + jotmXar + " not equal!");
            return;
        }

        MCInfo mci = (MCInfo) mc2mci.get(jotmMc);
        if (mci == null) {
            trace.log(BasicLevel.ERROR, "no mci found for " + jotmMc);
            return;
        }

        try {
            mci.mc.cleanup();

            // Release the MC from its pool
            poolMCs.releaseResource(mci.mc, false, true);
        } catch (Exception ex) {
            trace.log(BasicLevel.ERROR, ex.getMessage(), ex);
        }

        jotmMc = null;
        jotmXar = null;
    }
}

---