@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()); } });
@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()); } });
public static void finalizeTransaction(TransactionStatus status, PlatformTransactionManager transactionManager, boolean isError) { boolean isActive = false; try { if (!status.isRollbackOnly()) { isActive = true; } } catch (Exception e) { //do nothing } if (isError || !isActive) { try { transactionManager.rollback(status); } catch (Exception e) { LOG.error("Rolling back caused exception. Logging and continuing.", e); } } else { transactionManager.commit(status); } }
@Test public void transactionTemplateWithCallbackPreference() { MockCallbackPreferringTransactionManager ptm = new MockCallbackPreferringTransactionManager(); TransactionTemplate template = new TransactionTemplate(ptm); template.execute(new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(TransactionStatus status) { } }); assertSame(template, ptm.getDefinition()); assertFalse(ptm.getStatus().isRollbackOnly()); }
@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()); } });
@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); } });
/** * Check that a transaction is created and committed using * CallbackPreferringPlatformTransactionManager. */ @Test public void transactionShouldSucceedWithCallbackPreference() throws Exception { TransactionAttribute txatt = new DefaultTransactionAttribute(); MapTransactionAttributeSource tas = new MapTransactionAttributeSource(); tas.register(getNameMethod, txatt); MockCallbackPreferringTransactionManager ptm = new MockCallbackPreferringTransactionManager(); TestBean tb = new TestBean(); ITestBean itb = (ITestBean) advised(tb, ptm, tas); checkTransactionStatus(false); itb.getName(); checkTransactionStatus(false); assertSame(txatt, ptm.getDefinition()); assertFalse(ptm.getStatus().isRollbackOnly()); }
@Test public void transactionExceptionPropagatedWithCallbackPreference() throws Throwable { TransactionAttribute txatt = new DefaultTransactionAttribute(); MapTransactionAttributeSource tas = new MapTransactionAttributeSource(); tas.register(exceptionalMethod, txatt); MockCallbackPreferringTransactionManager ptm = new MockCallbackPreferringTransactionManager(); TestBean tb = new TestBean(); ITestBean itb = (ITestBean) advised(tb, ptm, tas); checkTransactionStatus(false); try { itb.exceptional(new OptimisticLockingFailureException("")); fail("Should have thrown OptimisticLockingFailureException"); } catch (OptimisticLockingFailureException ex) { // expected } checkTransactionStatus(false); assertSame(txatt, ptm.getDefinition()); assertFalse(ptm.getStatus().isRollbackOnly()); }
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 public boolean isRollbackOnly() { return status.isRollbackOnly(); }
/** * * {@inheritDoc} */ public boolean isRollbackOnly( ) { return getMainTransactionStatus( ).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; } }
public boolean isRollbackOnly() { return getMainTransactionStatus().isRollbackOnly(); }
public boolean isRollbackOnly() { return getMainTransactionStatus().isRollbackOnly(); }
@Override public boolean isRollbackOnly() { return getTransactionStatus() .orElseThrow(() -> new IllegalTransactionStatusException("the transaction is not active")) .isRollbackOnly(); }
@Override public void complete() throws IllegalStateException { if(status.isRollbackOnly()) { manager.rollback(status); }else{ manager.commit(status); } }
@Override public void onClose(Stage stage) { LOG.debug("{} nodes to {}", handled, mode); if (status.isCompleted()) { LOG.warn("cannot close stage: transaction is already completed!"); return; } LOG.trace("flushing JPA session for EntityManager {}", em); em.flush(); if (status.isRollbackOnly()) { LOG.debug("rolling back transaction {}", status); manager.rollback(status); } else { LOG.debug("commiting transaction {}", status); manager.commit(status); } } }
public static boolean isRollbackOnly() { TransactionAspectSupport.TransactionInfo transactionInfo = currentTransactionInfo(); if (transactionInfo != null && transactionInfo.hasTransaction()) { return transactionInfo.getTransactionStatus().isRollbackOnly(); } return false; }
else if (txnStatus.isRollbackOnly())
else if (transactionStatus.isRollbackOnly())