Re: [Connector] UserTransaction incomplete

[David Jencks]

I'm working on this, hope to have something committed later today.  
Fairly extensive modifications are needed.  I hope to make UT available 
in Jetty to show what is needed to use in other contexts.

Thanks for pointing out that this is incomplete.
david jencks
On Monday, April 5, 2004, at 10:49 AM, Hamilton Verissimo de Oliveira 
(Engenharia - SPO) wrote:

Following this issue, here is the UserTransactionImpl.java. Attention 
to
begin/commit/rollback and incrementTransaction and 
decrementTransaction.

- Someone needs to set the TrackedConnectionAssociator to
UserTransactionImpl sometime. When?
- Should ConnectionTrackingCoordinator be a singleton?
it's a GBean in geronimo.  You should be able to deploy outside 
geronimo by creating one yourself.
- UserTransactionImpl could actively obtain a
ConnectionTrackingCoordinator.getInstance() as the default
TrackedConnectionAssociator.
- I didn't follow the "TODO this needs to migrate to using
TransactionContext."
Need some help on this.
--
hammett
http://jroller.com/page/hammett/
http://www.apache.org/~hammett/
/**
 * TODO this needs to migrate to using TransactionContext.
 * TODO this needs to notify the TrackedConnectionAssociator when a tx
starts.
 *
 * @version $Revision: 1.5 $ $Date: 2004/03/10 09:59:37 $
 */
public class UserTransactionImpl implements UserTransaction, 
Serializable
{
	///
	/// Instance members
	///
	
    private transient TransactionManager transactionManager;

    private transient TrackedConnectionAssociator
trackedConnectionAssociator;
    private transient TransactionContext oldContext;
        ///
        /// Constructors
        ///
    public UserTransactionImpl()
    {
    }
        //
        // UserTransaction implementation
        //
    public TransactionManager getTransactionManager()
    {
        return transactionManager;
    }
    public void setTransactionManager(TransactionManager 
transactionManager)
    {
        this.transactionManager = transactionManager;
    }

    public TrackedConnectionAssociator getTrackedConnectionAssociator()
    {
        return trackedConnectionAssociator;
    }
    public void 
setTrackedConnectionAssociator(TrackedConnectionAssociator
trackedConnectionAssociator)
    {
        this.trackedConnectionAssociator = trackedConnectionAssociator;
    }

    public void begin() throws NotSupportedException, SystemException
    {
        checkState();
        transactionManager.begin();
        // In the case of exception here shall we rollback the
        // brand new transaction?
        incrementTransaction();
    }
    public void commit()
        throws
            HeuristicMixedException,
            HeuristicRollbackException,
            IllegalStateException,
            RollbackException,
            SecurityException,
            SystemException
    {
        checkState();
        transactionManager.commit();
        decrementTransaction();
    }
    public int getStatus() throws SystemException
    {
        checkState();
        return transactionManager.getStatus();
    }
    public void rollback() throws IllegalStateException, 
SecurityException,
SystemException
    {
        checkState();
        transactionManager.rollback();

                decrementTransaction();
    }
    public void setRollbackOnly() throws IllegalStateException,
SystemException
    {
        checkState();
        transactionManager.setRollbackOnly();
    }
    public void setTransactionTimeout(int timeout) throws 
SystemException
    {
        checkState();
        transactionManager.setTransactionTimeout(timeout);
    }

    //
    // Private implementation
    //
        private void checkState()
        {
                //        if (transactionManager == null ||
trackedConnectionAssociator == null) {
                //            throw new
IllegalStateException("UserTransaction is disabled");
                //        }
        }
    private void incrementTransaction() throws SystemException
    {
                if (trackedConnectionAssociator == null)
                {
                        return;
                }
                
                try
                {
                        Transaction transaction =
transactionManager.getTransaction();
                        DefaultTransactionContext context = new
DefaultTransactionContext(transaction);
                        
                        // What to do with old context?
                        // Will we support nested transactions?
                        oldContext =
trackedConnectionAssociator.setTransactionContext(context);
                }
                catch(Exception ex)
                {
                        throw new SystemException(ex.getMessage());
                }
    }
        private void decrementTransaction() throws SystemException
        {
                if (trackedConnectionAssociator == null)
                {
                        return;
                }
                
                try
                {
        
trackedConnectionAssociator.resetTransactionContext(oldContext);
                }
                catch(Exception ex)
                {
                        throw new SystemException(ex.getMessage());
                }
        }
}