Example usage for org.springframework.transaction.support DefaultTransactionStatus isDebug

List of usage examples for org.springframework.transaction.support DefaultTransactionStatus isDebug

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.transaction.support.*
  5. DefaultTransactionStatus
  6. isDebug

Introduction

In this page you can find the example usage for org.springframework.transaction.support DefaultTransactionStatus isDebug.

Prototype

public boolean isDebug()

Source Link

Document

Return whether the progress of this transaction is debugged.

Usage

From source file:com._4dconcept.springframework.data.marklogic.datasource.ContentSourceTransactionManager.java

@Override
protected void doRollback(DefaultTransactionStatus status) {
    ContentSourceTransactionObject txObject = (ContentSourceTransactionObject) status.getTransaction();
    Session ses = txObject.getSessionHolder().getSession();
    if (status.isDebug()) {
        logger.debug("Rolling back XDBC transaction on Session [" + ses + "]");
    }//from   w w w. j  ava 2  s  .c  o m
    try {
        ses.rollback();
    } catch (XccException ex) {
        throw new TransactionSystemException("Could not roll back XDBC transaction", ex);
    }
}

From source file:org.cfr.capsicum.datasource.CayenneTransactionManager.java

@Override
protected void doCommit(DefaultTransactionStatus status) {
    CayenneTransactionObject txObject = (CayenneTransactionObject) status.getTransaction();
    Connection con = txObject.getConnectionHolder().getConnection();
    if (status.isDebug()) {
        logger.debug("Committing JDBC transaction on Connection [" + con + "]");
    }/*w ww  .  ja va 2s  .c  om*/
    try {
        status.flush();
        con.commit();
    } catch (SQLException ex) {
        throw new TransactionSystemException("Could not commit JDBC transaction",
                exceptionTranslator.convertJdbcAccessException(ex));
    } catch (CayenneRuntimeException ex) {
        throw new TransactionSystemException("Could not commit JDBC transaction",
                exceptionTranslator.convertAccessException(ex));
    }
}

From source file:org.cfr.capsicum.datasource.CayenneTransactionManager.java

@Override
protected void doRollback(DefaultTransactionStatus status) {
    CayenneTransactionObject txObject = (CayenneTransactionObject) status.getTransaction();
    Connection con = txObject.getConnectionHolder().getConnection();
    ObjectContext dataContext = txObject.getConnectionHolderEx().getObjectContext();
    if (status.isDebug()) {
        logger.debug("Rolling back JDBC transaction on Connection [" + con + "]");
    }//  w w w.  jav  a2s  .  c o m
    try {
        if (dataContext != null) {
            dataContext.rollbackChanges();
        }
        con.rollback();
    } catch (SQLException ex) {
        throw new TransactionSystemException("Could not commit JDBC transaction",
                exceptionTranslator.convertJdbcAccessException(ex));
    } catch (CayenneRuntimeException ex) {
        throw new TransactionSystemException("Could not commit JDBC transaction",
                exceptionTranslator.convertAccessException(ex));
    }
}

From source file:com.newmainsoftech.spray.slingong.datastore.Slim3PlatformTransactionManagerTest.java

protected void verifyRollbackProcess(boolean readOnlyEnabled, boolean roolBackOnlyEnabled,
        boolean debugEnabled) {
    // public final void rollback(TransactionStatus status)
    // private void processRollback(DefaultTransactionStatus status)
    // protected final void triggerBeforeCompletion(DefaultTransactionStatus status)

    ArgumentCaptor<DefaultTransactionStatus> defaultTransactionStatusArgumentCaptor = ArgumentCaptor
            .forClass(DefaultTransactionStatus.class);
    mockedSlim3TxMangerInOrder.verify(slim3PlatformTransactionManager, Mockito.times(1))
            .doRollback(defaultTransactionStatusArgumentCaptor.capture());
    DefaultTransactionStatus defaultTransactionStatus = defaultTransactionStatusArgumentCaptor.getValue();
    Assert.assertTrue(defaultTransactionStatus.getTransaction() instanceof GlobalTransaction);
    GlobalTransaction gtx = (GlobalTransaction) defaultTransactionStatus.getTransaction();
    Assert.assertTrue(defaultTransactionStatus.isNewTransaction());
    Assert.assertTrue(defaultTransactionStatus.isCompleted()); // Should be true since actually transaction has already been finished
    Assert.assertEquals(readOnlyEnabled, defaultTransactionStatus.isReadOnly());
    Assert.assertEquals(roolBackOnlyEnabled, defaultTransactionStatus.isRollbackOnly());
    /* If defaultTransactionStatus.isRollbackOnly() returns true, then either 
     * its isGlobalRollbackOnly() or its isLocalRollbackOnly() returns true.
     *//*from   w  ww.  j  a v a2  s . c  o  m*/
    if (defaultTransactionStatus.isRollbackOnly() && logger.isDebugEnabled()) {
        logger.debug("defaultTransactionStatus.isGlobalRollbackOnly() = "
                + defaultTransactionStatus.isGlobalRollbackOnly());
        logger.debug("defaultTransactionStatus.isLocalRollbackOnly() = "
                + defaultTransactionStatus.isLocalRollbackOnly());
    }
    Assert.assertEquals(debugEnabled, defaultTransactionStatus.isDebug());
    Assert.assertFalse(defaultTransactionStatus.isTransactionSavepointManager());
    Assert.assertTrue(defaultTransactionStatus.isNewSynchronization());

    mockedSlim3TxMangerInOrder.verify(slim3PlatformTransactionManager, Mockito.times(1))
            .getGlobalTransactionStates(Mockito.eq(gtx));

    // private void triggerAfterCompletion(DefaultTransactionStatus status, int completionStatus)
    // private void cleanupAfterCompletion(DefaultTransactionStatus status)
    // protected void doCleanupAfterCompletion(Object transaction)

}

From source file:org.springframework.transaction.support.AbstractPlatformTransactionManager.java

/**
 * This implementation of commit handles participating in existing
 * transactions and programmatic rollback requests.
 * Delegates to {@code isRollbackOnly}, {@code doCommit}
 * and {@code rollback}./*  w  w w  .jav  a  2s.  c  o m*/
 * @see org.springframework.transaction.TransactionStatus#isRollbackOnly()
 * @see #doCommit
 * @see #rollback
 */
@Override
public final void commit(TransactionStatus status) throws TransactionException {
    if (status.isCompleted()) {
        throw new IllegalTransactionStateException(
                "Transaction is already completed - do not call commit or rollback more than once per transaction");
    }

    DefaultTransactionStatus defStatus = (DefaultTransactionStatus) status;
    if (defStatus.isLocalRollbackOnly()) {
        if (defStatus.isDebug()) {
            logger.debug("Transactional code has requested rollback");
        }
        processRollback(defStatus, false);
        return;
    }

    if (!shouldCommitOnGlobalRollbackOnly() && defStatus.isGlobalRollbackOnly()) {
        if (defStatus.isDebug()) {
            logger.debug(
                    "Global transaction is marked as rollback-only but transactional code requested commit");
        }
        processRollback(defStatus, true);
        return;
    }

    processCommit(defStatus);
}

From source file:org.springframework.transaction.support.AbstractPlatformTransactionManager.java

/**
 * Process an actual commit.//from w w  w  .j  a va2 s .  c  om
 * Rollback-only flags have already been checked and applied.
 * @param status object representing the transaction
 * @throws TransactionException in case of commit failure
 */
private void processCommit(DefaultTransactionStatus status) throws TransactionException {
    try {
        boolean beforeCompletionInvoked = false;

        try {
            boolean unexpectedRollback = false;
            prepareForCommit(status);
            triggerBeforeCommit(status);
            triggerBeforeCompletion(status);
            beforeCompletionInvoked = true;

            if (status.hasSavepoint()) {
                if (status.isDebug()) {
                    logger.debug("Releasing transaction savepoint");
                }
                unexpectedRollback = status.isGlobalRollbackOnly();
                status.releaseHeldSavepoint();
            } else if (status.isNewTransaction()) {
                if (status.isDebug()) {
                    logger.debug("Initiating transaction commit");
                }
                unexpectedRollback = status.isGlobalRollbackOnly();
                doCommit(status);
            } else if (isFailEarlyOnGlobalRollbackOnly()) {
                unexpectedRollback = status.isGlobalRollbackOnly();
            }

            // Throw UnexpectedRollbackException if we have a global rollback-only
            // marker but still didn't get a corresponding exception from commit.
            if (unexpectedRollback) {
                throw new UnexpectedRollbackException(
                        "Transaction silently rolled back because it has been marked as rollback-only");
            }
        } catch (UnexpectedRollbackException ex) {
            // can only be caused by doCommit
            triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);
            throw ex;
        } catch (TransactionException ex) {
            // can only be caused by doCommit
            if (isRollbackOnCommitFailure()) {
                doRollbackOnCommitException(status, ex);
            } else {
                triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);
            }
            throw ex;
        } catch (RuntimeException | Error ex) {
            if (!beforeCompletionInvoked) {
                triggerBeforeCompletion(status);
            }
            doRollbackOnCommitException(status, ex);
            throw ex;
        }

        // Trigger afterCommit callbacks, with an exception thrown there
        // propagated to callers but the transaction still considered as committed.
        try {
            triggerAfterCommit(status);
        } finally {
            triggerAfterCompletion(status, TransactionSynchronization.STATUS_COMMITTED);
        }

    } finally {
        cleanupAfterCompletion(status);
    }
}

From source file:org.springframework.transaction.support.AbstractPlatformTransactionManager.java

/**
 * Process an actual rollback.//from  ww w  .  j av a2  s .  com
 * The completed flag has already been checked.
 * @param status object representing the transaction
 * @throws TransactionException in case of rollback failure
 */
private void processRollback(DefaultTransactionStatus status, boolean unexpected) {
    try {
        boolean unexpectedRollback = unexpected;

        try {
            triggerBeforeCompletion(status);

            if (status.hasSavepoint()) {
                if (status.isDebug()) {
                    logger.debug("Rolling back transaction to savepoint");
                }
                status.rollbackToHeldSavepoint();
            } else if (status.isNewTransaction()) {
                if (status.isDebug()) {
                    logger.debug("Initiating transaction rollback");
                }
                doRollback(status);
            } else {
                // Participating in larger transaction
                if (status.hasTransaction()) {
                    if (status.isLocalRollbackOnly() || isGlobalRollbackOnParticipationFailure()) {
                        if (status.isDebug()) {
                            logger.debug(
                                    "Participating transaction failed - marking existing transaction as rollback-only");
                        }
                        doSetRollbackOnly(status);
                    } else {
                        if (status.isDebug()) {
                            logger.debug(
                                    "Participating transaction failed - letting transaction originator decide on rollback");
                        }
                    }
                } else {
                    logger.debug("Should roll back transaction but cannot - no transaction available");
                }
                // Unexpected rollback only matters here if we're asked to fail early
                if (!isFailEarlyOnGlobalRollbackOnly()) {
                    unexpectedRollback = false;
                }
            }
        } catch (RuntimeException | Error ex) {
            triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);
            throw ex;
        }

        triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);

        // Raise UnexpectedRollbackException if we had a global rollback-only marker
        if (unexpectedRollback) {
            throw new UnexpectedRollbackException(
                    "Transaction rolled back because it has been marked as rollback-only");
        }
    } finally {
        cleanupAfterCompletion(status);
    }
}

From source file:org.springframework.transaction.support.AbstractPlatformTransactionManager.java

/**
 * Invoke {@code doRollback}, handling rollback exceptions properly.
 * @param status object representing the transaction
 * @param ex the thrown application exception or error
 * @throws TransactionException in case of rollback failure
 * @see #doRollback// w w  w. j av  a 2 s  .  c  o m
 */
private void doRollbackOnCommitException(DefaultTransactionStatus status, Throwable ex)
        throws TransactionException {
    try {
        if (status.isNewTransaction()) {
            if (status.isDebug()) {
                logger.debug("Initiating transaction rollback after commit exception", ex);
            }
            doRollback(status);
        } else if (status.hasTransaction() && isGlobalRollbackOnParticipationFailure()) {
            if (status.isDebug()) {
                logger.debug("Marking existing transaction as rollback-only after commit exception", ex);
            }
            doSetRollbackOnly(status);
        }
    } catch (RuntimeException | Error rbex) {
        logger.error("Commit exception overridden by rollback exception", ex);
        triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);
        throw rbex;
    }
    triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);
}

From source file:org.springframework.transaction.support.AbstractPlatformTransactionManager.java

/**
 * Trigger {@code beforeCommit} callbacks.
 * @param status object representing the transaction
 *//*www.j a  v  a2 s . c o m*/
protected final void triggerBeforeCommit(DefaultTransactionStatus status) {
    if (status.isNewSynchronization()) {
        if (status.isDebug()) {
            logger.trace("Triggering beforeCommit synchronization");
        }
        TransactionSynchronizationUtils.triggerBeforeCommit(status.isReadOnly());
    }
}

From source file:org.springframework.transaction.support.AbstractPlatformTransactionManager.java

/**
 * Trigger {@code beforeCompletion} callbacks.
 * @param status object representing the transaction
 *///from   www . j  ava2 s  . c om
protected final void triggerBeforeCompletion(DefaultTransactionStatus status) {
    if (status.isNewSynchronization()) {
        if (status.isDebug()) {
            logger.trace("Triggering beforeCompletion synchronization");
        }
        TransactionSynchronizationUtils.triggerBeforeCompletion();
    }
}