PoolItem.java

package org.objectweb.jonas.dbm;

import javax.sql.XAConnection;
import javax.transaction.Synchronization;
import javax.transaction.Transaction;

import org.objectweb.jonas.common.Log;
import org.objectweb.transaction.jta.ResourceManagerEvent;
import org.objectweb.util.monolog.api.BasicLevel;
import org.objectweb.util.monolog.api.Logger;

public class PoolItem implements ResourceManagerEvent, Synchronization {

    private static int count = 0;

    private XAConnection xaConn; // the pooled connection
    private String user;         // the user name
    private int open;            // >0 if connection is open
    private Transaction tx;  // transaction the connection is involved with
    private Transaction enlistedInTx; 
    private boolean rme = false; // true if registered as ResourceManagerEvent
    private long deathTime;     // When it is expected to die (for closed connections)
    private long closeTime;     // When it is expected to be closed (for opened connections)
    private int number;
    private Pool pool;
    private Logger logger = null;

    /*
     * constructor used by newConnection()
     */
    public PoolItem(Pool pool, XAConnection xac, String user) {
        this.pool = pool;
        this.xaConn = xac;
        this.user = user;
        open = 0;
        deathTime = System.currentTimeMillis() + pool.getMaxAgeMilli();
        number = count++;
        logger = Log.getLogger(Log.JONAS_DBM_PREFIX);
    }

    /*
     * string form for debugging
     */
    public String toString() {
        Integer i = new Integer(number);
        return i.toString();
    }

    public void enlistConnection(Transaction transaction) throws javax.transaction.SystemException  {
        try {
            if (rme) {
                xaConn.getConnection().setAutoCommit(false);
                // the tx value of the pool item does not match with the enlisted value !?
                enlistedInTx = transaction;
                // enlist the resource
                if (logger.isLoggable(BasicLevel.DEBUG))
                    logger.log(BasicLevel.DEBUG, "enlist XAResource on " + transaction);
                transaction.enlistResource(xaConn.getXAResource());
            }
        } catch (javax.transaction.RollbackException e) {
            throw new javax.transaction.SystemException("Unexpected RollbackException exception: "+e.getMessage());
        } catch (java.sql.SQLException e) {
            throw new javax.transaction.SystemException("Unexpected SQL exception: "+e.getMessage());
        }
    }

    public void beforeCompletion() {
        // nothing to do
    }

    public void afterCompletion(int status) {
        if (tx == null ) {
            logger.log(BasicLevel.ERROR, "NO TX!");
        }
        pool.freeConnections(tx != null ? tx : enlistedInTx);
    }

    public boolean isAged() {
        return (deathTime < System.currentTimeMillis());
    }

    public boolean isOpen() {
        return (open > 0);
    }

    public int getOpenCount() {
        return open;
    }

    public boolean inactive() {
        return (open > 0 && tx == null && enlistedInTx == null && closeTime < System.currentTimeMillis());
    }

    public boolean isClosed() {
        return (open <= 0);
    }

    public void open() {
        open++;
        closeTime = System.currentTimeMillis() + pool.getMaxOpenTimeMilli();
    }

    public boolean close() {
        open--;
        if (open < 0) {
            logger.log(BasicLevel.WARN, "connection was already closed");
            open = 0;
            return false;
        }
        if (tx == null && open > 0) {
            logger.log(BasicLevel.ERROR, "connection-open counter overflow");
            open = 0;
        }
        return true;
    }

    public XAConnection getXACon() {
        return xaConn;
    }

    public void setTx(Transaction tx) {
        this.tx = tx;
    }

    public Transaction getTx() {
        return tx;
    }

    public boolean isRME() {
        return rme;
    }

    public void setRME(boolean rme) {
        this.rme = rme;
    }

    public void remove() {
        // Close the physical connection
        try {
            xaConn.close();
        } catch (java.sql.SQLException ign) {
            logger.log(BasicLevel.ERROR, "Could not close Connection: " + ign);
        }

        // remove all references (for GC)
        xaConn = null;
        tx = null;
        enlistedInTx = null;
    }
}

---