TransactionServiceImpl.java

package org.objectweb.jonas.jtm;

import java.rmi.RemoteException;

import javax.management.MBeanServer;
import javax.management.ObjectName;
import javax.management.modelmbean.ModelMBean;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.transaction.UserTransaction;
import javax.transaction.xa.Xid;

import org.apache.commons.modeler.ManagedBean;
import org.apache.commons.modeler.Registry;
import org.objectweb.jonas.common.Log;
import org.objectweb.jonas.jmx.J2eeObjectName;
import org.objectweb.jonas.jmx.JmxService;
import org.objectweb.jonas.jmx.JonasObjectName;
import org.objectweb.jonas.management.JonasMBeanTools;
import org.objectweb.jonas.naming.NamingManager;
import org.objectweb.jonas.service.AbsServiceImpl;
import org.objectweb.jonas.service.ServiceException;
import org.objectweb.jonas.service.ServiceManager;
import org.objectweb.jotm.Current;
import org.objectweb.jotm.TransactionFactory;
import org.objectweb.jotm.TransactionFactoryImpl;
import org.objectweb.transaction.jta.TransactionManager;
import org.objectweb.util.monolog.api.BasicLevel;
import org.objectweb.util.monolog.api.Logger;

public class TransactionServiceImpl extends AbsServiceImpl implements TransactionService, TransactionServiceImplMBean {

    private static Logger logger = null;

    public static final String SERVICE_NAME = "jtm";
    // Transaction Service configuration properties
    static final String TIMEOUT = "jonas.service.jtm.timeout";
    static final String REMOTE = "jonas.service.jtm.remote";
    static final String CLASS = "jonas.service.jtm.class";

    private TransactionFactory tm = null;

    private Current current = null;

    private Xid myXid [] = null;

    // Configuration information used to start the Transaction service
    private int timeout;
    private boolean jtmlocal;
    private InitialContext ictx;

    private Registry oRegistry = null;
    private MBeanServer mbeanServer = null;
    // -------------------------------------------------------------------
    // JOnAS Service Implementation
    // -------------------------------------------------------------------

    public void doInit(Context ctx) throws ServiceException {

        // get logger for this service
        logger = Log.getLogger(Log.JONAS_SERVER_PREFIX);
        super.initLogger(Log.getLogger(Log.JONAS_MANAGEMENT_PREFIX));

        // Gets the configuration
        String remote = "false";
        try {
            remote = (String) ctx.lookup(REMOTE);
        } catch (NamingException e) {
            // No problem if there is no value --> default value
        }
        if ((remote != null) && (!remote.equals(""))) {
            jtmlocal = !remote.equalsIgnoreCase("true");
        } else {
            jtmlocal = false;
        }

        String tstr = "60";
        try {
            tstr = (String) ctx.lookup(TIMEOUT);
        } catch (NamingException e) {
            // No problem if there is no value --> default value
        }
        if ((tstr != null) && (!tstr.equals(""))) {
            timeout = (new Integer(tstr)).intValue();
        } else {
            timeout = 60;
        }

        // Get the JMX Server via JMX Service
        try {
            mbeanServer =
                ((JmxService) ServiceManager.getInstance().getJmxService()).getJmxServer();
        } catch (Exception e) {
            // the JMX service may not be started
            mbeanServer = null;
        }
        // Use Jakarta Common Modeler API
        oRegistry = JonasMBeanTools.getRegistry();

        logger.log(BasicLevel.DEBUG, "TransactionService initialized. Timeout = " + timeout);
    }

    public void doStart() throws ServiceException {
        try {
            ictx = NamingManager.getInstance().getInitialContext();
        } catch (NamingException e) {
            logger.log(BasicLevel.ERROR, "TransactionService: Cannot get InitialContext:\n" + e);
            throw new ServiceException("TransactionService: Cannot get InitialContext", e);
        }

        // Gets the Distributed Transaction Manager (JTM)
        if (jtmlocal) {
            // Creates a JTM locally in this server
            logger.log(BasicLevel.DEBUG, "working with a colocated Transaction Manager ");

            // TODO: Recovery of the JTM

            // Creates the ControlFactory and register it in JNDI.
            try {
                logger.log(BasicLevel.DEBUG, "Create and register TM factory");
                tm = new TransactionFactoryImpl();
                ictx.rebind("TMFactory", tm);
            } catch (RemoteException e) {
                logger.log(BasicLevel.ERROR, "TransactionService: Cannot create TransactionFactory:\n" + e);
                throw new ServiceException("TransactionService: Cannot create TransactionFactory",
                                           e);
            } catch (NamingException e) {
                logger.log(BasicLevel.ERROR, "TransactionService: Cannot rebind TM:\n" + e);
                throw new ServiceException("TransactionService: Cannot rebind TM", e);
            }
        } else {
            // JTM is remote, finds it by JNDI
            logger.log(BasicLevel.DEBUG, "working with a remote Transaction Manager ");
            final int maxloops = 5;
            for (int i = 0; i <= maxloops; i++) {
                try {
                    tm = (TransactionFactory) ictx.lookup("TMFactory");
                    break;
                } catch (NamingException e) {
                    if (i < maxloops) {
                        logger.log(BasicLevel.WARN, "Cannot get TM factory - retrying...");
                        try {
                            Thread.sleep(2000 * (i + 1));
                        } catch (InterruptedException e2) {
                            throw new ServiceException("Cannot get TM factory", e2);
                        }
                    } else {
                        logger.log(BasicLevel.ERROR, "TransactionService: Cannot get TM factory:\n" + e);
                        throw new ServiceException("TransactionService: Cannot get TM factory", e);
                    }
                }
            }
        }

        // Create and init the unique Current object.
        // Current is the local TransactionManager. It must be present in every
        // jonas server and implements the JTA TransactionManager interface.
        //
        // In case of a JTM standalone:
        // We must create the current only to export it via JNDI for clients
        // that want to get UserTransaction.
        current = new Current(tm);
        setTimeout(timeout);

       try {
            if (mbeanServer != null) {
                // Register TransactionService MBean : only used by jo,nasAdmin's tree builder
                mbeanServer.registerMBean(this, JonasObjectName.transactionService());

                // JTAResource implemented by this Service
                // ------------------------------------------------
                try {
                    String sJTAResourceName = "JTAResource";
                    ObjectName onJTAResource =
                        J2eeObjectName.JTAResource(getDomainName(),
                                                   getJonasServerName(),
                                                   sJTAResourceName);
                    JTAResource jtaResourceMBean = new JTAResource(onJTAResource.toString(), this,
                            new Integer(timeout),
                            new Boolean(jtmlocal),
                            new Integer(tm.getPortNumber()),
                            tm.getHostName());
                    ManagedBean oManaged = oRegistry.findManagedBean("JTAResource");
                    ModelMBean oMBean = oManaged.createMBean(jtaResourceMBean);
                    if (logger.isLoggable(BasicLevel.DEBUG)) {
                        logger.log(BasicLevel.DEBUG, "JTAResource J2EEResource created");
                    }
                    mbeanServer.registerMBean(oMBean, onJTAResource);
                } catch (Exception e) {
                    e.printStackTrace();
                    logger.log(BasicLevel.ERROR, "JOnAS: Cannot register JTAResource mBean" + e);
                }
            }
        }  catch (ServiceException se) {
            // Jmx Service not available, do nothing
        }  catch (Exception e) {
            logger.log(BasicLevel.ERROR, "TransactionService: Cannot start the Transaction service:\n" + e);
            throw new ServiceException("TransactionService: Cannot start the Transaction service", e);
        }

        logger.log(BasicLevel.DEBUG, "TransactionService started, default timeout= " + timeout);
    }

    public void doStop() throws ServiceException {
        logger.log(BasicLevel.DEBUG, "Stop of TransactionService not already implemented");
    }

    // -------------------------------------------------------------------
    // TransactionService Implementation
    // -------------------------------------------------------------------

    public Current getCurrent() {
        return current;
    }

    public TransactionManager getTransactionManager() {
        return (TransactionManager) current;
    }

    public UserTransaction getUserTransaction() {
        return (UserTransaction) current;
    }

    public TransactionFactory getTransactionFactory() {
        return tm;
    }

    public void setTimeout(int t) {

        logger.log(BasicLevel.DEBUG, "" + t);
        current.setDefaultTimeout(t);

        // Register a UserTransactionFactory in JNDI.
        // Only if we are inside the JTM
        if (jtmlocal) {
            try {
                logger.log(BasicLevel.DEBUG, "Register UserTransactionFactory");
                NamingManager.getInstance().getInitialContext().rebind("javax.transaction.UserTransaction", current);
            } catch (NamingException e) {
                logger.log(BasicLevel.ERROR, "Cannot rebind UserTransaction:" + e);
            }
        }

    }

    protected int getTotalBegunTransactions() {
        return current.getTotalBegunTransactions();
    }

    protected int getTotalCommittedTransactions() {
        return current.getTotalCommittedTransactions();
    }

    protected int getTotalCurrentTransactions() {
        return current.getTotalCurrentTransactions();
    }

    protected int getTotalExpiredTransactions() {
        return current.getTotalExpiredTransactions();
    }

    protected int getTotalRolledbackTransactions() {
        return current.getTotalRolledbackTransactions();
    }

    protected void resetAllTxTotalCounters() {
        current.resetAllTxTotalCounters();
    }

    protected Xid [] getAllActiveXids() {
        return (current.getAllXid());
    }

    protected String [] getAllActiveTx() {
        String [] mysArray;

        mysArray = current.getAllTx();
        return mysArray;
    }
}

---