/** * Iterate over the list of Synchronizations to complete all the methods to be performed after * completion * * @param status int The status of the Global transaction associated with the transaction */ void notifyAfterCompletion(int status) throws SystemException { Iterator iterator = syncList.iterator(); while (iterator.hasNext()) { sync = ((Synchronization) iterator.next()); sync.afterCompletion(status); } }
@Override public void notifySynchronizationsAfterTransactionCompletion(int status) { if ( synchronizations != null ) { for ( Synchronization synchronization : synchronizations ) { try { synchronization.afterCompletion( status ); } catch ( Throwable t ) { LOG.synchronizationFailed( synchronization, t ); } } } }
@Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { if ( "afterCompletion".equals( method.getName() ) ) { int status = args[2].equals(Boolean.TRUE) ? Status.STATUS_COMMITTED : Status.STATUS_UNKNOWN; synchronization.afterCompletion(status); } else if ( "beforeCompletion".equals( method.getName() ) ) { synchronization.beforeCompletion(); } else if ( "toString".equals( method.getName() ) ) { return synchronization.toString(); } return null; }
private void fireAfterCompletion(int status) { for (Synchronization synchronization : synchronizations) { synchronization.afterCompletion(status); } }
@Override public void afterCompletion(final int status) { try { NamespaceContextSelector.pushCurrentSelector(selector); synchronization.afterCompletion(status); } finally { NamespaceContextSelector.popCurrentSelector(); } }
@Override public void notifySynchronizationsAfterTransactionCompletion(int status) { log.tracef( "SynchronizationRegistryStandardImpl.notifySynchronizationsAfterTransactionCompletion(%s)", status ); if ( synchronizations != null ) { try { for ( Synchronization synchronization : synchronizations ) { try { synchronization.afterCompletion( status ); } catch (Throwable t) { log.synchronizationFailed( synchronization, t ); throw new LocalSynchronizationException( "Exception calling user Synchronization (afterCompletion): " + synchronization.getClass().getName(), t ); } } } finally { clearSynchronizations(); } } }
preJcaSync.afterCompletion(status); } catch (Exception e) { jcaSync.afterCompletion(status); } catch (Exception e) {
public void afterCompletion(final int status) { try { if (importBacking()) try { sync.afterCompletion(status); } finally { unimportBacking(); } else { performConsumer(Synchronization::afterCompletion, sync, status); } } catch (SystemException e) { throw new SynchronizationException(e); } } }
@Test public void jtaTransactionManagerWithExistingTransactionAndJtaSynchronization() throws Exception { UserTransaction ut = mock(UserTransaction.class); TransactionManager tm = mock(TransactionManager.class); MockJtaTransaction tx = new MockJtaTransaction(); given(ut.getStatus()).willReturn(Status.STATUS_ACTIVE); given(tm.getTransaction()).willReturn(tx); final TransactionSynchronization synch = mock(TransactionSynchronization.class); JtaTransactionManager ptm = newJtaTransactionManager(ut, tm); TransactionTemplate tt = new TransactionTemplate(ptm); assertFalse(TransactionSynchronizationManager.isSynchronizationActive()); tt.execute(new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(TransactionStatus status) { assertTrue(TransactionSynchronizationManager.isSynchronizationActive()); TransactionSynchronizationManager.registerSynchronization(synch); status.setRollbackOnly(); } }); assertFalse(TransactionSynchronizationManager.isSynchronizationActive()); assertNotNull(tx.getSynchronization()); tx.getSynchronization().beforeCompletion(); tx.getSynchronization().afterCompletion(Status.STATUS_ROLLEDBACK); verify(ut).setRollbackOnly(); verify(synch).beforeCompletion(); verify(synch).afterCompletion(TransactionSynchronization.STATUS_ROLLED_BACK); }
public void afterCompletion(int status) { for(Synchronization sync : otherSync) { sync.afterCompletion(status); } } }
public void afterCompletion(StandardTransaction.State transactionState) { if (transactionState == StandardTransaction.State.COMMITTED) { synchronization.afterCompletion(Status.STATUS_COMMITTED); } else if (transactionState == StandardTransaction.State.ROLLEDBACK) { synchronization.afterCompletion(Status.STATUS_ROLLEDBACK); } else { throw new TransactionException("invalid transaction state: " + transactionState); } }
public void afterCompletion(int status) { int length = this.synchronizations.size(); for (int i = 0; i < length; i++) { Synchronization synchronization = this.synchronizations.get(i); synchronization.afterCompletion(status); } // end-for }
public void synchAfterCompletion(int res) { if (synchronizations.get() != null) { for (Synchronization s : synchronizations.get()) { s.afterCompletion(res); } } }
private void doAfterCompletion(int status) { if ( afterExecuted ) { log.tracef( "Transaction's afterCompletion() phase already been processed, ignoring: %s", delegate ); } else { delegate.afterCompletion( status ); afterExecuted = true; } } }
private void doAfterCompletion(final int status) { for (final Synchronization sync : new ArrayList<Synchronization>(registeredSynchronizations)) { try { sync.afterCompletion(status); } catch (final RuntimeException e) { logger.warning("Synchronization afterCompletion threw a RuntimeException", e); } } }
@Override public void rollback() throws IllegalStateException, SystemException { if (status != Status.STATUS_ACTIVE && status != Status.STATUS_MARKED_ROLLBACK) throw new SystemException("Unable to rollback: invalid tx status: " + status); status = Status.STATUS_ROLLEDBACK; for (Synchronization sync : syncs) { sync.afterCompletion(Status.STATUS_ROLLEDBACK); } }
@Override public void doAfterTransactionCompletion(boolean success, SharedSessionContractImplementor sessionImplementor) { try { synchronization.afterCompletion( success ? Status.STATUS_COMMITTED : Status.STATUS_ROLLEDBACK ); } catch (Exception e) { throw new HibernateException( "Error while indexing in Hibernate Search (after transaction completion)", e ); } } }
@Override public void afterCompletion(final int status) { try { NamespaceContextSelector.pushCurrentSelector(selector); synchronization.afterCompletion(status); } finally { NamespaceContextSelector.popCurrentSelector(); } }
public void end() { this.progress = false; for ( Synchronization sync : syncs ) { sync.beforeCompletion(); } for ( Synchronization sync : syncs ) { sync.afterCompletion( Status.STATUS_COMMITTED ); } } }
@Override public void registerSynchronization(Synchronization synch) throws IllegalStateException, RollbackException, SystemException { LOGGER.debug("Registering a synchronization with the current transaction"); TransactionContext currentContext = getTxControl().getCurrentContext(); currentContext.preCompletion(synch::beforeCompletion); currentContext.postCompletion(status -> synch.afterCompletion(toIntStatus(status))); }