Glassfish example source code file (TransactionImpl.java)

This example Glassfish source code file (TransactionImpl.java) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Java - Glassfish tags/keywords

controlimpl, corba, exception, exception, illegalstateexception, illegalstateexception, invalid_transaction, log, logging, rollbackexception, rollbackexception, systemexception, systemexception, transaction, transaction_rolledback, transactionimpl, transactionstate, unavailable, util

The Glassfish TransactionImpl.java source code

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright (c) 1997-2011 Oracle and/or its affiliates. All rights reserved.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common Development
 * and Distribution License("CDDL") (collectively, the "License").  You
 * may not use this file except in compliance with the License.  You can
 * obtain a copy of the License at
 * https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
 * or packager/legal/LICENSE.txt.  See the License for the specific
 * language governing permissions and limitations under the License.
 *
 * When distributing the software, include this License Header Notice in each
 * file and include the License file at packager/legal/LICENSE.txt.
 *
 * GPL Classpath Exception:
 * Oracle designates this particular file as subject to the "Classpath"
 * exception as provided by Oracle in the GPL Version 2 section of the License
 * file that accompanied this code.
 *
 * Modifications:
 * If applicable, add the following below the License Header, with the fields
 * enclosed by brackets [] replaced by your own identifying information:
 * "Portions Copyright [year] [name of copyright owner]"
 *
 * Contributor(s):
 * If you wish your version of this file to be governed by only the CDDL or
 * only the GPL Version 2, indicate your decision by adding "[Contributor]
 * elects to include this software in this distribution under the [CDDL or GPL
 * Version 2] license."  If you don't indicate a single choice of license, a
 * recipient has the option to distribute your version of this file under
 * either the CDDL, the GPL Version 2 or to extend the choice of license to
 * its licensees as provided above.  However, if you add GPL Version 2 code
 * and therefore, elected the GPL Version 2 license, then the option applies
 * only if the new code is made subject to such option by the copyright
 * holder.
 */

package com.sun.jts.jta;

import java.util.*;
import org.omg.CosTransactions.*;
import javax.transaction.*;
import javax.transaction.xa.*;

import com.sun.jts.CosTransactions.Configuration;
import com.sun.jts.CosTransactions.ControlImpl;
import com.sun.jts.CosTransactions.TopCoordinator;
import com.sun.jts.CosTransactions.GlobalTID;

import javax.transaction.Synchronization;
import javax.transaction.SystemException;

import org.omg.CosTransactions.Status;
import org.omg.CORBA.TRANSACTION_ROLLEDBACK;
import org.omg.CORBA.INVALID_TRANSACTION;
import org.omg.CORBA.NO_PERMISSION;
import java.util.logging.Logger;
import java.util.logging.Level;

import com.sun.logging.LogDomains;
import com.sun.enterprise.transaction.spi.TransactionInternal;

/**
 * An implementation of javax.transaction.Transaction using JTS
 * XXX TODO should catch all org.omg.CORBA.SystemException
 * and throw javax.transaction.SystemException
 *
 * @author Tony Ng
 */
public class TransactionImpl implements TransactionInternal {

    /**
     * OTS Control object for this transaction
     */
    private Control control;

    private GlobalTID gtid;

    private TransactionState tranState = null;

    private static TransactionManagerImpl tm = TransactionManagerImpl.getTransactionManagerImpl();
	/*
		Logger to log transaction messages
	*/  
    static Logger _logger = LogDomains.getLogger(TransactionImpl.class, LogDomains.TRANSACTION_LOGGER);

    // START 4662745
    private long startTime;
    // END 4662745

    public TransactionImpl(Control control, GlobalTID gtid)
        throws SystemException {

        this.control = control;
        this.gtid = gtid;
        startTime=System.currentTimeMillis();
    }

    /**
     * return the OTS Control object for this transaction.
     */
    Control getControl() {
        return control;
    }

    //-----------------------------------------------------------------
    // The following implements javax.transaction.Trasaction interface
    //-----------------------------------------------------------------

    /**
     * Complete the transaction represented by this Transaction object
     */
    public void commit() throws HeuristicMixedException,
        RollbackException, HeuristicRollbackException, IllegalStateException,
        SecurityException, SystemException
    {
        try {
            if (Configuration.isLocalFactory()) {
              ((ControlImpl) control).get_localTerminator().commit(true);
            } else {
                control.get_terminator().commit(true);
            }
        } catch (TRANSACTION_ROLLEDBACK ex) {
            RollbackException rbe = new RollbackException();
            Throwable cause = ex.getCause();
            if (cause != null) {
                rbe.initCause(cause);
            }
            throw rbe;
        } catch (INVALID_TRANSACTION ex) {
            throw new IllegalStateException();
        } catch (HeuristicMixed ex) {
            throw new HeuristicMixedException();
        } catch (HeuristicHazard ex) {
            throw new HeuristicMixedException();
        } catch (NO_PERMISSION ex) {
            throw new SecurityException();
        } catch (Unavailable ex) {
            SystemException sException = new SystemException();
            sException.initCause(ex);
            throw sException;
        } catch (Exception ex) {
            SystemException sException = new SystemException();
            sException.initCause(ex);
            throw sException;
        }

    }


    /**
     * Rollback the transaction represented by this Transaction object.
     */
    public void rollback()
        throws IllegalStateException, SystemException {

        try {
            if (Configuration.isLocalFactory()) {
              ((ControlImpl) control).get_localTerminator().rollback();
            } else {
              control.get_terminator().rollback();
            }
        } catch (INVALID_TRANSACTION ex) {
            throw new IllegalStateException();
        } catch (TRANSACTION_ROLLEDBACK ex) {
            throw new IllegalStateException();
        } catch (Unavailable ex) {
            SystemException sException = new SystemException();
            sException.initCause(ex);
            throw sException;
        } catch (Exception ex) {
            SystemException sException = new SystemException();
            sException.initCause(ex);
            throw sException;
        }
    }


    /**
     * enlist a resource with the current transaction
     * If a transaction is marked as rollback, enlistment will
     * succeed if the resource has been enlisted before. Otherwise,
     * enlistment will fail. In both cases, a RollbackException will
     * be thrown.
     */
    public boolean enlistResource(XAResource res)
        throws RollbackException, IllegalStateException,
            SystemException {

        int status = getStatus();
        if (status != javax.transaction.Status.STATUS_ACTIVE &&
            status != javax.transaction.Status.STATUS_MARKED_ROLLBACK) {
            throw new IllegalStateException();
        }
	//START IASRI 4706150
	try{
	    if(tm.getXAResourceTimeOut() > 0)
	        res.setTransactionTimeout(tm.getXAResourceTimeOut());
	}catch(Exception ex){
	    _logger.log(Level.WARNING,"jts.error_while_setting_xares_txn_timeout",ex);
	}
	//END IASRI 4706150
        try {
            if (tranState == null) {
                tranState = new TransactionState(gtid, this);
                // Synchronization sync = new SynchronizationListener(tranState);
                // registerSynchronization(sync);
            }
            tranState.startAssociation(res, control, status);
            if (status == javax.transaction.Status.STATUS_MARKED_ROLLBACK) {
                throw new RollbackException();
            }
            return true;
        } catch (XAException ex) {
			_logger.log(Level.WARNING,"jts.resource_outside_transaction",ex);
            if (ex.errorCode == XAException.XAER_OUTSIDE) {
                throw new IllegalStateException();
            }
            // XXX FIXME should throw rollback exception on XARB_*
            // for now just throw SystemException
            throw new SystemException();
        }

    }

    public boolean delistResource(XAResource res, int flags)
        throws IllegalStateException, SystemException {

        /*
        int status = getStatus();
        if (status != javax.transaction.Status.STATUS_ACTIVE &&
            status != javax.transaction.Status.STATUS_MARKED_ROLLBACK) {
            throw new IllegalStateException();
        }
        */

        try {
            // TransactionState tranState = tm.getTransactionState(gtid, this);
            if (tranState == null) {
                // transaction has completed
                throw new IllegalStateException();
            }
            if (tranState.containsXAResource(res) == false) {
                throw new IllegalStateException();
            }
            tranState.endAssociation(res, flags);
            if ((flags & XAResource.TMFAIL) != 0) {
                // set transaction to rollback only if TMFAIL used
                setRollbackOnly();
            }
            return true;
        } catch (XAException ex) {
            setRollbackOnly();
            SystemException se = new SystemException();
            se.initCause(ex);
            throw se;
        }
    }

    public int getStatus() throws SystemException {
        // XXX what should getStatus return on exception?
        Status  status;
        try {
            if (Configuration.isLocalFactory()) {
              status = ((ControlImpl) control).get_localCoordinator().get_status();
            } else {
              status = control.get_coordinator().get_status();
            }
            return TransactionManagerImpl.mapStatus(status);
        } catch (TRANSACTION_ROLLEDBACK ex) {
            return javax.transaction.Status.STATUS_NO_TRANSACTION;
        } catch (INVALID_TRANSACTION ex) {
            return javax.transaction.Status.STATUS_NO_TRANSACTION;
        } catch (Unavailable ex) {
            return javax.transaction.Status.STATUS_NO_TRANSACTION;
        } catch (Exception ex) {
			_logger.log(Level.WARNING,"jts.unexpected_error_in_getstatus",ex);
            throw new SystemException();
        }
    }

    public boolean equals(Object object) {
        if ((object instanceof TransactionImpl) == false) {
            return false;
        } else if (object == this) {
            return true;
        } else {
            return gtid.equals(((TransactionImpl) object).gtid);
        }
    }

    public int hashCode() {
        return gtid.hashCode();
    }

    public void registerSynchronization(Synchronization sync)
        throws RollbackException, IllegalStateException,
        SystemException {

        int status = getStatus();
        if (status == javax.transaction.Status.STATUS_MARKED_ROLLBACK) {
            throw new RollbackException();
        }
        if (status != javax.transaction.Status.STATUS_ACTIVE) {
            throw new IllegalStateException();
        }
        if (tranState == null) {
            tranState = new TransactionState(gtid, this);
        }
        tranState.registerSynchronization(sync, control, false);
    }

    public void registerInterposedSynchronization(Synchronization sync)
        throws RollbackException, IllegalStateException,
        SystemException {

        int status = getStatus();
        if (status == javax.transaction.Status.STATUS_MARKED_ROLLBACK) {
            throw new RollbackException();
        }
        if (status != javax.transaction.Status.STATUS_ACTIVE) {
            throw new IllegalStateException();
        }
        if (tranState == null) {
            tranState = new TransactionState(gtid, this);
        }
        tranState.registerSynchronization(sync, control, true);
    }

    public void setRollbackOnly()
        throws IllegalStateException, SystemException {

        int status = getStatus();
        if (status != javax.transaction.Status.STATUS_MARKED_ROLLBACK &&
            status != javax.transaction.Status.STATUS_ACTIVE) {
            throw new IllegalStateException();
        }
        try {
            if (Configuration.isLocalFactory()) {
              ((ControlImpl) control).get_localCoordinator().rollback_only();
            } else {
              control.get_coordinator().rollback_only();
            }
        } catch (Inactive ex) {
            IllegalStateException ise = new IllegalStateException();
            ise.initCause(ex);
            throw ise;
        } catch (Exception ex) {
            SystemException se = new SystemException();
            se.initCause(ex);
            throw se;
        }
    }


    /**
     * a simple assertion mechanism that print stack trace
     * if assertion fails
     */
    static private void assert_prejdk14(boolean value) {
        if (!value) {
            Exception e = new Exception();
			_logger.log(Level.WARNING,"jts.assert",e);
        }
    }
    // START IASRI 4662745
    /*
     * This method is used for the Admin Framework displaying
     * of Transactions Ids
     */
    public String getTransactionId(){
        return gtid.toString();
    }

    /*
     * This method returns the time this transaction was started
     */
    public long getStartTime(){
        return startTime;
    }
    // END IASRI 4662745


/**
class SynchronizationListener implements Synchronization {

    private GlobalTID gtid;
    private TransactionState tranState;

    SynchronizationListener(TransactionState tranState) {
        this.tranState = tranState;
    }

    public void afterCompletion(int status) {
        // tranState.cleanupTransactionStateMapping();
    }

    public void beforeCompletion() {
        try {
	    tranState.beforeCompletion();
	}catch(XAException xaex){
	    _logger.log(Level.WARNING,"jts.unexpected_xa_error_in_beforecompletion", new java.lang.Object[] {new Integer(xaex.errorCode), xaex.getMessage()});
	    _logger.log(Level.WARNING,"",xaex);
        } catch (Exception ex) {
	    _logger.log(Level.WARNING,"jts.unexpected_error_in_beforecompletion",ex);
        }
    }
}
**/

}