@Override protected void doInTransactionWithoutResult(TransactionStatus status) { status.setRollbackOnly(); } });
/** * Determine whether a test-managed transaction is currently <em>active</em>. * @return {@code true} if a test-managed transaction is currently active * @see #start() * @see #end() */ public static boolean isActive() { TransactionContext transactionContext = TransactionContextHolder.getCurrentTransactionContext(); if (transactionContext != null) { TransactionStatus transactionStatus = transactionContext.getTransactionStatus(); return (transactionStatus != null && !transactionStatus.isCompleted()); } return false; }
@Override protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { assertFalse("Is not rollback-only", status.isRollbackOnly()); tt2.execute(new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { status.setRollbackOnly(); } }); assertTrue("Is rollback-only", status.isRollbackOnly()); } });
/** * Commits the transaction with given {@code status} if the transaction is new and not completed. * * @param status The status of the transaction to commit */ protected void commitTransaction(TransactionStatus status) { if (status.isNewTransaction() && !status.isCompleted()) { transactionManager.commit(status); } }
@Override protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { assertTrue("Is new transaction", status.isNewTransaction()); status.setRollbackOnly(); } });
@Override protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { assertTrue("Is new transaction", status.isNewTransaction()); Object savepoint = status.createSavepoint(); status.rollbackToSavepoint(savepoint); assertTrue("Is new transaction", status.isNewTransaction()); } });
protected void doInTransactionWithoutResult(TransactionStatus status) { // wrapper exception to throw if the exchange failed // IMPORTANT: Must be a runtime exception to let Spring regard it as to do "rollback" RuntimeException rce; // and now let process the exchange by the error handler processByErrorHandler(exchange); // after handling and still an exception or marked as rollback only then rollback if (exchange.getException() != null || exchange.isRollbackOnly()) { // wrap exception in transacted exception if (exchange.getException() != null) { rce = ObjectHelper.wrapRuntimeCamelException(exchange.getException()); } else { // create dummy exception to force spring transaction manager to rollback rce = new TransactionRollbackException(); } if (!status.isRollbackOnly()) { status.setRollbackOnly(); } // throw runtime exception to force rollback (which works best to rollback with Spring transaction manager) if (log.isTraceEnabled()) { log.trace("Throwing runtime exception to force transaction to rollback on {}", transactionTemplate.getName()); } throw rce; } } });
@Override protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { assertTrue("Is new transaction", status.isNewTransaction()); } });
@Override protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { assertTrue("Is existing transaction", !status.isNewTransaction()); assertFalse("Is not rollback-only", status.isRollbackOnly()); tt.execute(new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { assertTrue("Has thread connection", TransactionSynchronizationManager.hasResource(ds)); assertTrue("Synchronization active", TransactionSynchronizationManager.isSynchronizationActive()); assertTrue("Is existing transaction", !status.isNewTransaction()); status.setRollbackOnly(); } }); assertTrue("Is existing transaction", !status.isNewTransaction()); assertTrue("Is rollback-only", status.isRollbackOnly()); } });
protected static int convertToJtaStatus(TransactionStatus status) { if (status != null) { if (status.isCompleted()) { return Status.STATUS_UNKNOWN; } else if (status.isRollbackOnly()) { return Status.STATUS_MARKED_ROLLBACK; } else { return Status.STATUS_ACTIVE; } } else { return Status.STATUS_NO_TRANSACTION; } }
@Override protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { assertTrue("Is new transaction", status.isNewTransaction()); assertTrue("Isn't nested transaction", !status.hasSavepoint()); tt.execute(new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { assertTrue("Has thread connection", TransactionSynchronizationManager.hasResource(ds)); assertTrue("Synchronization active", TransactionSynchronizationManager.isSynchronizationActive()); assertTrue("Isn't new transaction", !status.isNewTransaction()); assertTrue("Is nested transaction", status.hasSavepoint()); status.setRollbackOnly(); } }); assertTrue("Is new transaction", status.isNewTransaction()); assertTrue("Isn't nested transaction", !status.hasSavepoint()); } });
@Override protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { assertTrue("Is new transaction", status.isNewTransaction()); Object savepoint = status.createSavepoint(); status.releaseSavepoint(savepoint); assertTrue("Is new transaction", status.isNewTransaction()); } });
@Override public Object doInTransaction(TransactionStatus status) { assertTrue(!TransactionSynchronizationManager.hasResource(factory)); assertTrue(TransactionSynchronizationManager.isSynchronizationActive()); assertTrue(!status.isNewTransaction()); EntityManagerFactoryUtils.getTransactionalEntityManager(factory).flush(); status.setRollbackOnly(); return null; } });
/** * Rolls back the transaction with given {@code status} if the transaction is new and not completed. * * @param status The status of the transaction to roll back */ protected void rollbackTransaction(TransactionStatus status) { if (status.isNewTransaction() && !status.isCompleted()) { transactionManager.rollback(status); } } }
@Override protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { assertTrue("Hasn't thread connection", !TransactionSynchronizationManager.hasResource(ds)); assertTrue("Is not new transaction", !status.isNewTransaction()); } });
@Override protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { assertTrue("Is existing transaction", !status.isNewTransaction()); assertFalse("Is not rollback-only", status.isRollbackOnly()); tt.execute(new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { assertTrue("Has thread connection", TransactionSynchronizationManager.hasResource(ds)); assertTrue("Synchronization active", TransactionSynchronizationManager.isSynchronizationActive()); assertTrue("Is existing transaction", !status.isNewTransaction()); status.setRollbackOnly(); } }); assertTrue("Is existing transaction", !status.isNewTransaction()); assertTrue("Is rollback-only", status.isRollbackOnly()); TransactionSynchronizationManager.registerSynchronization(synch); } });
@Override protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { assertTrue("Is new transaction", status.isNewTransaction()); assertTrue("Isn't nested transaction", !status.hasSavepoint()); for (int i = 0; i < count; i++) { tt.execute(new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { assertTrue("Has thread connection", TransactionSynchronizationManager.hasResource(ds)); assertTrue("Synchronization active", TransactionSynchronizationManager.isSynchronizationActive()); assertTrue("Isn't new transaction", !status.isNewTransaction()); assertTrue("Is nested transaction", status.hasSavepoint()); } }); } assertTrue("Is new transaction", status.isNewTransaction()); assertTrue("Isn't nested transaction", !status.hasSavepoint()); } });
@Override protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { status.setRollbackOnly(); } });
@Override public Object doInTransaction(TransactionStatus status) { assertTrue(TransactionSynchronizationManager.hasResource(factory)); assertTrue(TransactionSynchronizationManager.isSynchronizationActive()); assertTrue(!status.isNewTransaction()); EntityManagerFactoryUtils.getTransactionalEntityManager(factory).flush(); status.setRollbackOnly(); return null; } });
/** * This implementation of rollback handles participating in existing * transactions. Delegates to {@code doRollback} and * {@code doSetRollbackOnly}. * @see #doRollback * @see #doSetRollbackOnly */ @Override public final void rollback(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; processRollback(defStatus, false); }