@Override public void setRollbackOnly() throws SystemException { this.transactionManager.setRollbackOnly(); }
@Override public void setRollbackOnly() throws SystemException { this.transactionManager.setRollbackOnly(); }
/** {@inheritDoc} */ @Override public void setRollbackOnly() throws IllegalStateException, SystemException { mgr.setRollbackOnly(); }
/** * Calls setRollbackOnly() of the transaction manager owning this user transaction * * @see javax.transaction.UserTransaction#setRollbackOnly() */ @Override public void setRollbackOnly() throws IllegalStateException, SystemException { tm.setRollbackOnly(); }
@Override public void setRollbackOnly() throws SystemException { this.transactionManager.setRollbackOnly(); }
@Override public void setRollbackOnly() throws SystemException { this.transactionManager.setRollbackOnly(); }
private void doRollback(boolean isNew, Throwable originalException) { Throwable rollbackEx = null; try { if (isNew) { transactionManager.rollback(); } else { transactionManager.setRollbackOnly(); } } catch (SystemException e) { LOGGER.debug("Error when rolling back transaction", e); } catch (RuntimeException e) { rollbackEx = e; throw e; } catch (Error e) { rollbackEx = e; throw e; } finally { if (rollbackEx != null && originalException != null) { LOGGER.error("Error when rolling back transaction, original exception was:", originalException); } } }
@Override public void markRollbackOnly() { try { transactionManager.setRollbackOnly(); } catch (SystemException e) { throw new TransactionException( "Could not set transaction to rollback only", e ); } }
public void setRollbackOnly() throws IllegalStateException { if (isBeanManagedTransaction()) { throw EjbLogger.ROOT_LOGGER.failToCallSetRollbackOnlyOnNoneCMB(); } try { // get the transaction manager TransactionManager tm = getTransactionManager(); // check if there's a tx in progress. If not, then it's an error to call setRollbackOnly() if (tm.getTransaction() == null) { throw EjbLogger.ROOT_LOGGER.failToCallSetRollbackOnlyWithNoTx(); } // set rollback tm.setRollbackOnly(); } catch (SystemException se) { EjbLogger.ROOT_LOGGER.setRollbackOnlyFailed(se); } }
private void doRollback(boolean isNew) { try { if (isNew) { transactionManager.rollback(); } else { transactionManager.setRollbackOnly(); } } catch (SystemException e) { LOG.exceptionWhileRollingBackTransaction(e); } }
private void doRollback(boolean isNew) { try { if (isNew) { transactionManager.rollback(); } else { transactionManager.setRollbackOnly(); } } catch (SystemException e) { LOG.exceptionWhileRollingBackTransaction(e); } }
/** * {@inheritDoc} */ public void setRollbackOnly() throws IllegalStateException, SystemException { tm.setRollbackOnly(); }
/** * INTERNAL: * Mark the external transaction for rollback. */ protected void markTransactionForRollback_impl() throws Exception { getTransactionManager().setRollbackOnly(); }
public static void setRollbackOnly(TransactionManager tm) throws LjtSystemRuntimeException { try { tm.setRollbackOnly(); } catch (SystemException e) { throw new LjtSystemRuntimeException(e); } } }
/** * @see javax.transaction.UserTransaction */ public void setRollbackOnly () throws IllegalStateException, SystemException { checkSetup (); txmgr_.setRollbackOnly (); }
@Override public void setRollbackOnly() throws STransactionException { try { txManager.setRollbackOnly(); } catch (final IllegalStateException | SystemException e) { throw new STransactionException(e); } }
public void testMarkAsRollbackAfterMods() throws Exception { TransactionManager tm = TestingUtil.getTransactionManager(cache); assert tm != null; tm.begin(); cache.put("k", "v"); assert cache.get("k").equals("v"); tm.setRollbackOnly(); expectException(RollbackException.class, () -> tm.commit()); assert tm.getTransaction() == null : "There should be no transaction in scope anymore!"; assert cache.get("k") == null : "Expected a null but was " + cache.get("k"); }
public void testMarkAsRollbackBeforeMods() throws Exception { TransactionManager tm = TestingUtil.getTransactionManager(cache); assert tm != null; tm.begin(); tm.setRollbackOnly(); expectException(CacheException.class, IllegalStateException.class, () -> cache.put("k", "v")); expectException(RollbackException.class, () -> tm.commit()); assert tm.getTransaction() == null : "There should be no transaction in scope anymore!"; assert cache.get("k") == null : "Expected a null but was " + cache.get("k"); } }
public void testSizeInExplicitTx() throws Exception { assertEquals(0, cache.size()); cache.put("k", "v"); TransactionManager tm = TestingUtil.getTransactionManager(cache); withTx(tm, () -> { assertEquals(1, cache.size()); tm.setRollbackOnly(); return null; }); }
public void testSizeInExplicitTxWithModification() throws Exception { assertEquals(0, cache.size()); cache.put("k1", "v1"); TransactionManager tm = TestingUtil.getTransactionManager(cache); withTx(tm, () -> { assertNull(cache.put("k2", "v2")); assertEquals(2, cache.size()); tm.setRollbackOnly(); return null; }); }