Java Code Examples for javax.transaction.Status#STATUS_ROLLEDBACK

/**
 * {@inheritDoc}
 */
public void commit() throws RollbackException,
                            HeuristicMixedException,
                            HeuristicRollbackException,
                            SecurityException,
                            IllegalStateException,
                            SystemException
{
   Transaction tx = registry.getTransaction();

   if (tx == null)
      throw new SystemException();

   if (tx.getStatus() == Status.STATUS_ROLLING_BACK ||
       tx.getStatus() == Status.STATUS_ROLLEDBACK ||
       tx.getStatus() == Status.STATUS_MARKED_ROLLBACK)
      throw new RollbackException();

   registry.commitTransaction();
}
 

protected void recoverParticipant(Transaction transaction)
		throws CommitRequiredException, RollbackRequiredException, SystemException {

	TransactionImpl transactionImpl = (TransactionImpl) transaction;
	switch (transaction.getTransactionStatus()) {
	case Status.STATUS_PREPARED:
	case Status.STATUS_COMMITTING:
		break;
	case Status.STATUS_COMMITTED:
	case Status.STATUS_ROLLEDBACK:
		break;
	case Status.STATUS_ACTIVE:
	case Status.STATUS_MARKED_ROLLBACK:
	case Status.STATUS_PREPARING:
	case Status.STATUS_UNKNOWN:
	case Status.STATUS_ROLLING_BACK:
	default:
		transactionImpl.recoveryRollback();
		transactionImpl.forgetQuietly();
	}
}
 

@Override
public void afterCompletion(int status) {
	switch (status) {
		case Status.STATUS_COMMITTED:
			try {
				TransactionSynchronizationUtils.invokeAfterCommit(this.synchronizations);
			}
			finally {
				TransactionSynchronizationUtils.invokeAfterCompletion(
						this.synchronizations, TransactionSynchronization.STATUS_COMMITTED);
			}
			break;
		case Status.STATUS_ROLLEDBACK:
			TransactionSynchronizationUtils.invokeAfterCompletion(
					this.synchronizations, TransactionSynchronization.STATUS_ROLLED_BACK);
			break;
		default:
			TransactionSynchronizationUtils.invokeAfterCompletion(
					this.synchronizations, TransactionSynchronization.STATUS_UNKNOWN);
	}
}
 

/**
 * @see javax.transaction.UserTransaction#rollback
 */
@Override
public void rollback() throws IllegalStateException, SecurityException, SystemException {

    if (status != Status.STATUS_ACTIVE && status != Status.STATUS_MARKED_ROLLBACK) {

        throw new IllegalStateException("Transaction not active");
    }

    try {
        xares.end(xid, XAResource.TMFAIL);

        status = Status.STATUS_ROLLING_BACK;
        xares.rollback(xid);
        status = Status.STATUS_ROLLEDBACK;

    } catch (XAException e) {
        final SystemException systemException = new SystemException("Unable to commit transaction: " + "XA_ERR="
                + e.errorCode);
        systemException.initCause(e);
        throw systemException;
    }
}
 

/**
 * JTA {@code afterCompletion} callback: invoked after commit/rollback.
 * <p>Needs to invoke the Spring synchronization's {@code beforeCompletion}
 * at this late stage in case of a rollback, since there is no corresponding
 * callback with JTA.
 * @see org.springframework.transaction.support.TransactionSynchronization#beforeCompletion
 * @see org.springframework.transaction.support.TransactionSynchronization#afterCompletion
 */
@Override
public void afterCompletion(int status) {
	if (!this.beforeCompletionCalled) {
		// beforeCompletion not called before (probably because of JTA rollback).
		// Perform the cleanup here.
		this.springSynchronization.beforeCompletion();
	}
	// Call afterCompletion with the appropriate status indication.
	switch (status) {
		case Status.STATUS_COMMITTED:
			this.springSynchronization.afterCompletion(TransactionSynchronization.STATUS_COMMITTED);
			break;
		case Status.STATUS_ROLLEDBACK:
			this.springSynchronization.afterCompletion(TransactionSynchronization.STATUS_ROLLED_BACK);
			break;
		default:
			this.springSynchronization.afterCompletion(TransactionSynchronization.STATUS_UNKNOWN);
	}
}
 

public void rollback() throws MithraTransactionException
{
    if (this.proxyStatus == Status.STATUS_ACTIVE)
    {
        this.proxyStatus = Status.STATUS_ROLLING_BACK;
        this.delistAll(XAResource.TMFAIL);
        this.rollbackAllXaResources();
        this.handleCacheRollback();
        this.proxyStatus = Status.STATUS_ROLLEDBACK;
        this.notificationEvents.clear();
        afterCompletion();
    }
    else
    {
        throw new MithraTransactionException("Cannot rollback with proxyStatus " + getJtaTransactionStatusDescription(this.proxyStatus));
    }
}
 

public synchronized void commit() throws RollbackException, HeuristicMixedException, HeuristicRollbackException,
		SecurityException, IllegalStateException, CommitRequiredException, SystemException {

	if (this.transactionStatus == Status.STATUS_ACTIVE) {
		this.fireCommit();
	} else if (this.transactionStatus == Status.STATUS_MARKED_ROLLBACK) {
		this.fireRollback();
		throw new HeuristicRollbackException();
	} else if (this.transactionStatus == Status.STATUS_ROLLEDBACK) /* should never happen */ {
		throw new RollbackException();
	} else if (this.transactionStatus == Status.STATUS_COMMITTED) /* should never happen */ {
		logger.debug("Current transaction has already been committed.");
	} else {
		throw new IllegalStateException();
	}

}
 

/**
 * Commit the transaction.
 *
 * @throws RollbackException when a rollback error occurs.
 * @throws HeuristicMixedException when the heuristics were mixed.
 * @throws HeuristicRollbackException when a rollback error occurs.
 * @throws SecurityException when a security error occurs.
 * @throws IllegalStateException when the transaction is not active.
 * @throws SystemException when a serious error occurs.
 */
@Override
public synchronized void commit() throws RollbackException, HeuristicMixedException,
        HeuristicRollbackException, SecurityException,
        IllegalStateException, SystemException {
    handleBeforeCompletion();
    try {
        switch (status) {
            case Status.STATUS_COMMITTED:
                break;
            case Status.STATUS_MARKED_ROLLBACK: {
                rollback();
                throw new HeuristicRollbackException();
            }
            case Status.STATUS_ROLLEDBACK: {
                throw new RollbackException();
            }
            default: {
                status = Status.STATUS_COMMITTED;
            }
        }
    } finally {
        handleAfterCompletion();
    }
}
 

public void rollback() {
    try {
        doXAResources(Status.STATUS_ROLLEDBACK);
        doAfterCompletion(Status.STATUS_ROLLEDBACK);
        status = Status.STATUS_ROLLEDBACK;
        registeredSynchronizations.clear();
    } finally {
        threadTransaction.set(null);
    }
}
 

@Override
protected void tearDown() throws Exception
{
    try
    {
        if (txn.getStatus() != Status.STATUS_ROLLEDBACK && txn.getStatus() != Status.STATUS_COMMITTED)
        {
            txn.rollback();
        }
    }
    catch (Throwable e)
    {
        e.printStackTrace();
    }
}
 

@Override
public void setRollbackOnly()
{
    switch (txStatus) {
        case Status.STATUS_ACTIVE:
        case Status.STATUS_MARKED_ROLLBACK:
            txStatus = Status.STATUS_MARKED_ROLLBACK;
            break;
        case Status.STATUS_ROLLEDBACK:
            break;
        default :
            throw new TransactionManagementException(new IllegalStateException("no mock-tx on current thread"));
    }
}
 

public synchronized void rollback() throws IllegalStateException, SystemException {
	if (this.transactionStatus == Status.STATUS_UNKNOWN) {
		throw new IllegalStateException();
	} else if (this.transactionStatus == Status.STATUS_NO_TRANSACTION) {
		throw new IllegalStateException();
	} else if (this.transactionStatus == Status.STATUS_COMMITTED) /* should never happen */ {
		throw new IllegalStateException();
	} else if (this.transactionStatus == Status.STATUS_ROLLEDBACK) /* should never happen */ {
		logger.debug("Current transaction has already been rolled back.");
	} else {
		this.fireRollback();
	}
}
 

public void afterCompletion(int status) {
  if(Status.STATUS_ROLLEDBACK == status && TransactionState.ROLLED_BACK.equals(transactionState)) {
    transactionListener.execute(commandContext);
  } else if(Status.STATUS_COMMITTED == status && TransactionState.COMMITTED.equals(transactionState)) {
    transactionListener.execute(commandContext);
  }
}
 

/**
 * This implementation checks the UserTransaction's rollback-only flag.
 */
@Override
public boolean isRollbackOnly() {
	try {
		int jtaStatus = this.userTransaction.getStatus();
		return (jtaStatus == Status.STATUS_MARKED_ROLLBACK || jtaStatus == Status.STATUS_ROLLEDBACK);
	}
	catch (SystemException ex) {
		throw new TransactionSystemException("JTA failure on getStatus", ex);
	}
}
 

/**
 * This implementation checks the UserTransaction's rollback-only flag.
 */
@Override
public boolean isRollbackOnly() {
	if (this.userTransaction == null) {
		return false;
	}
	try {
		int jtaStatus = this.userTransaction.getStatus();
		return (jtaStatus == Status.STATUS_MARKED_ROLLBACK || jtaStatus == Status.STATUS_ROLLEDBACK);
	}
	catch (SystemException ex) {
		throw new TransactionSystemException("JTA failure on getStatus", ex);
	}
}
 

/**
 * {@inheritDoc}
 */
public void afterCompletion(int status)
{
   if (!cancel)
   {
      log.tracef("afterCompletion(%s): %s", status, AbstractTransactionalConnectionListener.this);

      // "Delist"
      transactionSynchronization = null;
      enlisted = false;

      if (connectionHandles.isEmpty())
      {
         if (Tracer.isEnabled() && status == Status.STATUS_ROLLEDBACK)
            Tracer.delistConnectionListener(cm.getPool().getConfiguration().getId(),
                                            getManagedConnectionPool(),
                                            AbstractTransactionalConnectionListener.this, "",
                                            true, true, false);

         cm.returnConnectionListener(AbstractTransactionalConnectionListener.this, false);
      }
      else
      {
         if (cm.getConnectionManagerConfiguration().isTracking() == null ||
             cm.getConnectionManagerConfiguration().isTracking().booleanValue())
         {
            log.activeHandles(cm.getPool().getConfiguration().getId(), connectionHandles.size());

            if (connectionTraces != null)
            {
               Iterator<Map.Entry<Object, Exception>> it = connectionTraces.entrySet().iterator();
               while (it.hasNext())
               {
                  Map.Entry<Object, Exception> entry = it.next();
                  log.activeHandle(entry.getKey(), entry.getValue());
               }

               log.txConnectionListenerBoundary(new Exception());
            }

            if (Tracer.isEnabled())
            {
               for (Object c : connectionHandles)
               {
                  Tracer.clearConnection(cm.getPool().getConfiguration().getId(),
                                         getManagedConnectionPool(),
                                         AbstractTransactionalConnectionListener.this, c);
               }
            }

            cm.returnConnectionListener(AbstractTransactionalConnectionListener.this, true);
         }
         else
         {
            log.tracef(new Exception("Connection across boundary"), "ConnectionListener=%s",
                       AbstractTransactionalConnectionListener.this);
         }
      }
   }
}
 

public synchronized void rollback()
        throws IllegalStateException, SecurityException, SystemException
{
    // perform checks
    TransactionInfo txnInfo = getTransactionInfo();
    
    int status = getStatus();
    // check the status
    if (status == Status.STATUS_ROLLING_BACK || status == Status.STATUS_ROLLEDBACK)
    {
        throw new IllegalStateException("The transaction has already been rolled back");
    }
    else if (status == Status.STATUS_COMMITTING || status == Status.STATUS_COMMITTED)
    {
        throw new IllegalStateException("The transaction has already been committed");
    }
    else if (txnInfo == null)
    {
        throw new IllegalStateException("No user transaction is active");
    }

    if (!finalized)
    {
        try
        {
            // force a rollback by generating an exception that will trigger a rollback
            completeTransactionAfterThrowing(txnInfo, new Exception());
        }
        finally
        {
            // make sure that we clean up the stack
            cleanupTransactionInfo(txnInfo);
            finalized = true;
            // clean up leaked transaction logging
            isBeginMatched = true;
            beginCallStack = null;
        }
    }

    // the internal status notes that we were specifically rolled back 
    internalStatus = Status.STATUS_ROLLEDBACK;
    
    // done
    if (logger.isDebugEnabled())
    {
        logger.debug("Rolled back user transaction: " + this);
    }
}
 

protected void doRollback(DefaultTransactionStatus arg0)
{
    status = Status.STATUS_ROLLEDBACK;
}
 

/**
 * @throws IllegalStateException if a transaction was not started
 */
public synchronized void commit()
        throws RollbackException, HeuristicMixedException, HeuristicRollbackException,
        SecurityException, IllegalStateException, SystemException
{
    // perform checks
    TransactionInfo txnInfo = getTransactionInfo();

    int status = getStatus();
    // check the status
    if (status == Status.STATUS_NO_TRANSACTION)
    {
        throw new IllegalStateException("The transaction has not yet begun");
    }
    else if (status == Status.STATUS_ROLLING_BACK || status == Status.STATUS_ROLLEDBACK)
    {
        throw new RollbackException("The transaction has already been rolled back");
    }
    else if (status == Status.STATUS_MARKED_ROLLBACK)
    {
        throw new RollbackException("The transaction has already been marked for rollback");
    }
    else if (status == Status.STATUS_COMMITTING || status == Status.STATUS_COMMITTED)
    {
        throw new IllegalStateException("The transaction has already been committed");
    }
    else if (status != Status.STATUS_ACTIVE || txnInfo == null)
    {
        throw new IllegalStateException("No user transaction is active");
    }
        
    if (!finalized)
    {
        try
        {
            // the status seems correct - we can try a commit
            commitTransactionAfterReturning(txnInfo);
        }
        catch (Throwable e)
        {
            if (logger.isDebugEnabled())
            {
                logger.debug("Transaction didn't commit", e);
            }
            // commit failed
            internalStatus = Status.STATUS_ROLLEDBACK;
            RollbackException re = new RollbackException("Transaction didn't commit: " + e.getMessage());
            // Stick the originating reason for failure into the exception.
            re.initCause(e);
            throw re;
        }
        finally
        {
            // make sure that we clean up the stack
            cleanupTransactionInfo(txnInfo);
            finalized = true;
            // clean up leaked transaction logging
            isBeginMatched = true;
            beginCallStack = null;
        }
    }
    
    // regardless of whether the transaction was finally committed or not, the status
    // as far as UserTransaction is concerned should be 'committed'
    
    // keep track that this UserTransaction was explicitly committed
    internalStatus = Status.STATUS_COMMITTED;
    
    // done
    if (logger.isDebugEnabled())
    {
        logger.debug("Committed user transaction: " + this);
    }
}
 

public synchronized void participantRollback() throws IllegalStateException, SystemException {

		// Recover if transaction is recovered from tx-log.
		this.recoverIfNecessary();

		if (this.transactionStatus != Status.STATUS_ROLLEDBACK) {
			this.fireRollback(); // TODO
		}

	}