ConnectionManager.java

package org.objectweb.jonas.dbm;

import java.io.Serializable;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;

import javax.naming.NamingException;
import javax.naming.Reference;
import javax.naming.Referenceable;
import javax.naming.StringRefAddr;
import javax.sql.ConnectionEvent;
import javax.sql.ConnectionEventListener;
import javax.sql.DataSource;
import javax.sql.XAConnection;
import javax.transaction.RollbackException;
import javax.transaction.SystemException;
import javax.transaction.Transaction;
import javax.transaction.xa.XAResource;

import org.objectweb.jonas.common.Log;
import org.objectweb.jonas.jdbc_xa.XADataSourceImpl;
import org.objectweb.jonas.jtm.TransactionService;
import org.objectweb.jonas.service.ServiceManager;
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;

public class ConnectionManager
    implements DataSource,
               Referenceable,
               Serializable,
               ConnectionEventListener {

    private static Logger logger = null;

    // The static table of all the ConnectionManager objects
    // Each ResourceManager has its own ConnectionManager (i.e. DataSource)
    private static Map cmList = new HashMap();

    private TransactionManager tm = null;

    private XADataSourceImpl xads = null;

    private Pool pool = null;

    public Pool getPool() {
        return pool;
    }

    // ----------------------------------------------------------
    // properties
    // ----------------------------------------------------------

    private String dSName = null;

    private String datasourceName;

    private String url = null;
    private String className = null;
    private String userName = null;
    private String password = null;

    private int isolationLevel = -1;
    private String isolationStr = null;

    private String currentMapperName = null;

    private boolean isClient = false;

    private String xaName = null;
    private String dsDescription = null;

    private static ResourceManagerEventListener rmListener = null;

    // -----------------------------------------------------------------
    // Constructors
    // -----------------------------------------------------------------

    public ConnectionManager() throws Exception {
        logger = Log.getLogger(Log.JONAS_DBM_PREFIX);

        // Set the TransactionManager
        try {
            // Modified for use with the gcj compiler
            ServiceManager sm = ServiceManager.getInstance();
            TransactionService ts = (TransactionService) sm.getTransactionService();
            tm = ts.getTransactionManager();
        } catch (Exception e) {
            throw e;
        }

        // set the Transaction Manager as being the listener for this RM
        setRMEListener(tm);       

        // Create the underlaying JDBC-XA driver
        // We do not use JNDI here. (should we do ?)
        // AD : do this before the Pool creation in order to allow the Pool constructor to access xads
        xads = new XADataSourceImpl();
        pool = new Pool(this, xads);
    }

    public ConnectionManager(boolean isClient) throws Exception { 
        logger = Log.getLogger(Log.JONAS_DBM_PREFIX);
        this.isClient = isClient;
        xads = new XADataSourceImpl();
    }

    public boolean isClientCase() {
        return isClient;
    }

    // -----------------------------------------------------------------
    // Properties
    // -----------------------------------------------------------------

    public void setRMEListener(ResourceManagerEventListener rmel) {
        rmListener = rmel;
    }

    public String getDSName() {
        return dSName;
    }

    public void setDSName(String s) {
        dSName = s;
        xads.setDataSourceName(s); // for getRMID!
        // Add it to the list
        cmList.put(s, this);
    }

    public String getUrl() {
        return url;
    }
    public void setUrl(String s) {
        url = s;
        // Forward it to JDBC-XA driver
        xads.setUrl(s);
    }

    public String getClassName() {
        return className;
    }
    public void setClassName(String s) throws ClassNotFoundException {
        className = s;
        // Forward it to JDBC-XA driver
        xads.setClassName(s);
    }

    public String getUserName() {
        return userName;
    }
    public void setUserName(String s) {
        userName = s;
        // Forward it to JDBC-XA driver
        xads.setUserName(s);
    }

    public String getPassword() {
        return password;
    }
    public void setPassword(String s) {
        password = s;
        // Forward it to JDBC-XA driver
        xads.setPassword(s);
    }

    public void setTransactionIsolation(String level) {
        logger.log(BasicLevel.DEBUG, level);
        if (level.equals("serializable")) {
            isolationLevel = Connection.TRANSACTION_SERIALIZABLE;
        } else if (level.equals("none")) {
            isolationLevel = Connection.TRANSACTION_NONE;
        } else if (level.equals("read_committed")) {
            isolationLevel = Connection.TRANSACTION_READ_COMMITTED;
        } else if (level.equals("read_uncommitted")) {
            isolationLevel = Connection.TRANSACTION_READ_UNCOMMITTED;
        } else if (level.equals("repeatable_read")) {
            isolationLevel = Connection.TRANSACTION_REPEATABLE_READ;
        } else {
            isolationStr = "default";
            return;
        }
        // Forward it to JDBC-XA driver
        isolationStr = level;
        xads.setTransactionIsolation(isolationLevel);
    }

    public String getTransactionIsolation() {
        logger.log(BasicLevel.DEBUG, isolationStr);
        return isolationStr;
    }

    public void setMapperName(String mappername) {
        currentMapperName = mappername;
    }

    public String getMapperName() {
        return currentMapperName;
    }

    public void poolConfigure(String connchecklevel,
                              String connmaxage,
                              String maxopentime,
                              String connteststmt,
                              String minconpool,
                              String maxconpool,
                              String maxwaittime,
                              String maxwaiters,
                              String samplingperiod) {

        // Configure pool
        pool.setCheckLevel((new Integer(connchecklevel)).intValue());
        // set con max age BEFORE min/max pool size.
        pool.setMaxAge((new Integer(connmaxage)).intValue());
        pool.setMaxOpenTime((new Integer(maxopentime)).intValue());
        pool.setTestStatement(connteststmt);
        pool.setPoolMin((new Integer(minconpool)).intValue());
        pool.setPoolMax((new Integer(maxconpool)).intValue());
        pool.setMaxWaitTime((new Integer(maxwaittime)).intValue());
        pool.setMaxWaiters((new Integer(maxwaiters)).intValue());
        pool.setSamplingPeriod((new Integer(samplingperiod)).intValue());
        if (logger.isLoggable(BasicLevel.DEBUG)) {
            logger.log(BasicLevel.DEBUG, "ConnectionManager configured with:");
            logger.log(BasicLevel.DEBUG, "   jdbcConnCheckLevel  = " + connchecklevel);
            logger.log(BasicLevel.DEBUG, "   jdbcConnMaxAge      = " + connmaxage);
            logger.log(BasicLevel.DEBUG, "   jdbcMaxOpenTime     = " + maxopentime);
            logger.log(BasicLevel.DEBUG, "   jdbcTestStmt        = " + connteststmt);
            logger.log(BasicLevel.DEBUG, "   minConPool          = " + pool.getPoolMin());
            logger.log(BasicLevel.DEBUG, "   maxConPool          = " + pool.getPoolMax());
            logger.log(BasicLevel.DEBUG, "   maxWaitTime         = " + pool.getMaxWaitTime());
            logger.log(BasicLevel.DEBUG, "   maxWaiters          = " + pool.getMaxWaiters());
            logger.log(BasicLevel.DEBUG, "   samplingPeriod      = " + pool.getSamplingPeriod());
        }
    }

    // -----------------------------------------------------------------
    // DataSource implementation
    // -----------------------------------------------------------------

    public Connection getConnection() throws SQLException {
        return getConnection(userName, password);
    }

    public Connection getConnection(String username, String password) throws SQLException {
        XAConnection xac = null;
        Transaction tx = null;
        try {
            tx = tm.getTransaction();
        } catch (NullPointerException n) {
            // current is null: we are not in a JOnAS Server.
            logger.log(BasicLevel.ERROR, "ConnectionManager: should not be used outside a JOnAS Server");
        } catch (SystemException e) {
            logger.log(BasicLevel.ERROR, "ConnectionManager: getTransaction failed:" + e);
        }
        if (logger.isLoggable(BasicLevel.DEBUG)) {
            logger.log(BasicLevel.DEBUG, "Tx = " + tx);
        }

        // Check if available XAConnection in the pool for this user
        PoolItem pi = pool.openConnection(username, (Transaction) tx);
        // get the xac associated to the new PoolItem
        xac = pi.getXACon();

        Connection ret = xac.getConnection();
        // Enlist XAResource if we are actually in a transaction
        if (tx != null) {
            if (pi.getOpenCount() == 1) { // Only if first/only thread
                try {
                    if (logger.isLoggable(BasicLevel.DEBUG)) {
                        logger.log(BasicLevel.DEBUG, "enlist XAResource on " + tx);
                    }
                    tx.enlistResource(xac.getXAResource());
                    // We are inside a transaction: no autocommit!
                    ret.setAutoCommit(false);
                } catch (RollbackException e) {
                    // Although tx has been marked to be rolled back,
                    // XAResource has been correctly enlisted.
                    logger.log(BasicLevel.WARN, "XAResource enlisted, but tx is marked rollback");
                } catch (IllegalStateException e) {
                    // In case tx is committed, no need to register resource!
                    ret.setAutoCommit(true);
                } catch (Exception e) {
                    logger.log(BasicLevel.ERROR, "Cannot enlist XAResource:" + e);
                    logger.log(BasicLevel.ERROR, "Connection will not be enlisted in a transaction");
                    // should return connection in the pool XXX
                    throw new SQLException("Cannot enlist XAResource");
                }
            }
        } else {
            ret.setAutoCommit(true);    // in case we do not start a Tx
        }
        // We are not in a transaction yet: we just make a pre-registration.
        // We are in a stateful bean, put it in the list too.
        if (!pi.isRME()) {
            logger.log(BasicLevel.DEBUG, "register this connection to the TM.");
            pi.setRME(true);
            rmListener.connectionOpened(pi);
        }
        // return a Connection object
        return ret;
    }

    public java.io.PrintWriter getLogWriter() throws SQLException {
        return xads.getLogWriter();
    }


    public void setLogWriter(java.io.PrintWriter out) throws SQLException {
        xads.setLogWriter(out);
    }


    public void setLoginTimeout(int seconds) throws SQLException {
        xads.setLoginTimeout(seconds);
    }

    public int getLoginTimeout() throws SQLException {
        return xads.getLoginTimeout();
    }

    // -----------------------------------------------------------------
    // ConnectionEventListener implementation
    // -----------------------------------------------------------------

    public void connectionClosed(ConnectionEvent event) {
        logger.log(BasicLevel.DEBUG, " ");

        XAConnection xac = (XAConnection) event.getSource();
        PoolItem pi = pool.closeConnection(xac, XAResource.TMSUCCESS);

        // remove it from the list of open connections for this thread
        // only if it was opened outside a tx.
        if (pi != null && pi.isRME()) {
            logger.log(BasicLevel.DEBUG, "unregister this connection to the TM.");
            pi.setRME(false);
            rmListener.connectionClosed(pi);
        }
    }

    public void connectionErrorOccurred(ConnectionEvent event) {
        logger.log(BasicLevel.DEBUG, "");

        XAConnection xac = (XAConnection) event.getSource();
        PoolItem pi = pool.closeConnection(xac, XAResource.TMFAIL);

        // remove it from the list of open connections for this thread
        // only if it was opened outside a tx.
        if (pi != null && pi.isRME()) {
            logger.log(BasicLevel.DEBUG, "unregister this connection to the TM.");
            pi.setRME(false);
            rmListener.connectionErrorOccured(pi);
        }
    }

    // -----------------------------------------------------------------
    // Referenceable implementation
    // -----------------------------------------------------------------

    public Reference getReference() throws NamingException {

        Reference ref = new Reference (this.getClass().getName(), 
                                       "org.objectweb.jonas.dbm.DataSourceFactory",
                                       null);
        // These values are used by ObjectFactory (see DataSourceFactory.java)
        ref.add(new StringRefAddr("datasource.name", getDSName()));
        ref.add(new StringRefAddr("datasource.url", getUrl()));
        ref.add(new StringRefAddr("datasource.classname", getClassName()));
        ref.add(new StringRefAddr("datasource.username", getUserName()));
        ref.add(new StringRefAddr("datasource.password", getPassword()));
        ref.add(new StringRefAddr("datasource.isolationlevel", getTransactionIsolation()));
        ref.add(new StringRefAddr("datasource.mapper", getMapperName()));
        Integer checklevel = new Integer(pool.getCheckLevel());
        ref.add(new StringRefAddr("connchecklevel", checklevel.toString()));
        Integer maxage = new Integer(pool.getMaxAge());
        ref.add(new StringRefAddr("connmaxage", maxage.toString()));
        Integer maxopentime = new Integer(pool.getMaxOpenTime());
        ref.add(new StringRefAddr("maxopentime", maxopentime.toString()));
        ref.add(new StringRefAddr("connteststmt", pool.getTestStatement()));
        Integer minpool = new Integer(pool.getPoolMin());
        ref.add(new StringRefAddr("minconpool", minpool.toString()));
        Integer maxpool = new Integer(pool.getPoolMax());
        ref.add(new StringRefAddr("maxconpool", maxpool.toString()));
        Integer maxwaittime = new Integer(pool.getMaxWaitTime());
        ref.add(new StringRefAddr("maxwaittime", maxwaittime.toString()));
        Integer maxwaiters = new Integer(pool.getMaxWaiters());
        ref.add(new StringRefAddr("maxwaiters", maxwaiters.toString()));
        Integer samplingperiod = new Integer(pool.getSamplingPeriod());
        ref.add(new StringRefAddr("samplingperiod", samplingperiod.toString()));
        return ref;
    }

    public static ConnectionManager getConnectionManager(String dsname) {
       
        ConnectionManager cm = (ConnectionManager) cmList.get(dsname);
        return cm;
    }

    public void closeAllConnection() {
        logger.log(BasicLevel.DEBUG, "");
        pool.closeAllConnections();
    }

    public static ResourceManagerEventListener getResourceManagerEventListener() {
        return rmListener;
    }

    public String getDatasourceName() {
        return datasourceName;
    }

    public void setDatasourceName(String s) {
        datasourceName = s;
    }

    public String getDataSourceDescription() {
        return dsDescription;
    }

    public void setDataSourceDescription(String dsDesc) {
        dsDescription = dsDesc;
    }
    public Integer getCurrentOpened() {
        return new Integer(pool.getCurrentOpened());
    }
}

---