@Unwrap public UserTransaction getTransaction() throws NamingException { try { return createUTTransaction(); } catch (NameNotFoundException nnfe) { try { return createCMTTransaction(); } catch (NameNotFoundException nnfe2) { return createNoTransaction(); } } }
protected UserTransaction createUTTransaction() throws NamingException { return new UTTransaction( getUserTransaction() ); }
protected UserTransaction getUserTransaction() throws NamingException { return Transaction.instance(); }
private static boolean isTransactionRolledBackOrMarkedRollback() { try { return Transaction.instance().isRolledBackOrMarkedRollback(); } catch (Exception e) { return false; } }
protected boolean isTransactionMarkedRollback() { try { return Transaction.instance().isMarkedRollback(); } catch (Exception e) { return false; } }
static boolean isTransactionRolledBackOrMarkedRollback() { try { return Transaction.instance().isRolledBackOrMarkedRollback(); } catch (Exception e) { return false; } }
protected void joinTransaction() { try { Transaction.instance().enlist( getEntityManager() ); } catch (SystemException se) { throw new RuntimeException("could not join transaction", se); } }
public void scheduleTransactionCompletionEvent(String type, Object... parameters) { Transaction.instance().registerSynchronization( new TransactionCompletionEvent(type, parameters) ); }
public void scheduleTransactionSuccessEvent(String type, Object... parameters) { Transaction.instance().registerSynchronization( new TransactionSuccessEvent(type, parameters) ); }
void commitOrRollback(String phaseString) { try { if (Transaction.instance().isActive()) { try { log.debug("committing transaction " + phaseString); Transaction.instance().commit(); } catch (IllegalStateException e) { log.warn("TX commit failed with illegal state exception. This may be " + "because the tx timed out and was rolled back in the background.", e); } } else if ( Transaction.instance().isRolledBackOrMarkedRollback()) { log.debug("rolling back transaction " + phaseString); Transaction.instance().rollback(); } } catch (Exception e) { throw new IllegalStateException("Could not commit transaction", e); } }
@Override public Object find(EntityManager entityManager) { if (entityManager == null) { throw new NullPointerException("EntityManager must not be null"); } try { Transaction.instance().enlist(entityManager); } catch (SystemException se) { throw new RuntimeException("could not join transaction", se); } return entityManager.find(getClazz(), getId()); }
/** * Implementation of {@link Home#joinTransaction() joinTransaction()} for * JPA. */ @Override protected void joinTransaction() { if ( getEntityManager().isOpen() ) { try { Transaction.instance().enlist( getEntityManager() ); } catch (SystemException se) { throw new RuntimeException("could not join transaction", se); } } }
private void close() { boolean transactionActive = false; try { transactionActive = Transaction.instance().isActive(); } catch (SystemException se) { log.debug("could not get transaction status while destroying persistence context"); } if ( transactionActive ) { throw new IllegalStateException("attempting to destroy the persistence context while an active transaction exists (try installing <transaction:ejb-transaction/>)"); } if ( log.isDebugEnabled() ) { log.debug("destroying seam managed session for session factory: " + sessionFactoryJndiName); } if (session!=null && session.isOpen()) { session.close(); } }
public void handleTransactionsBeforePhase(PhaseEvent event) { if ( Init.instance().isTransactionManagementEnabled() ) { PhaseId phaseId = event.getPhaseId(); boolean beginTran = phaseId == PhaseId.RENDER_RESPONSE || phaseId == ( Transaction.instance().isConversationContextRequired() ? PhaseId.APPLY_REQUEST_VALUES : PhaseId.RESTORE_VIEW ); //( phaseId == PhaseId.RENDER_RESPONSE && !Init.instance().isClientSideConversations() ); if (beginTran) { begin(phaseId); } } }
/** * Raise an event so that an observer may add a faces message when Seam-managed transactions fail. */ protected void raiseTransactionFailedEvent() { try { UserTransaction tx = Transaction.instance(); if ( tx.isRolledBackOrMarkedRollback() ) { if (Events.exists()) Events.instance().raiseEvent(TRANSACTION_FAILED, tx.getStatus()); } } catch (Exception e) {} //swallow silently, not important }
protected void rollbackTransactionIfNecessary() { try { UserTransaction transaction = Transaction.instance(); if ( transaction.isActiveOrMarkedRollback() || transaction.isRolledBack() ) { log.debug("killing transaction"); transaction.rollback(); } } catch (Exception te) { log.error("could not roll back transaction", te); } } }
private void joinTransaction() throws SystemException { UserTransaction transaction = Transaction.instance(); if ( transaction.isActive() ) { session.isOpen(); try { transaction.registerSynchronization(this); } catch (Exception e) { session.getTransaction().registerSynchronization(this); } synchronizationRegistered = true; } }
private void joinTransaction() throws SystemException { UserTransaction transaction = Transaction.instance(); if ( transaction.isActive() ) { transaction.enlist(entityManager); try { transaction.registerSynchronization(this); synchronizationRegistered = true; } catch (Exception e) { synchronizationRegistered = PersistenceProvider.instance().registerSynchronization(this, entityManager); } } }
UserTransaction tx = Transaction.instance(); try