@SuppressWarnings("unchecked") private static ConcurrentMap<Application, URI> getOrCreateApplicationMap(AbstractTransaction transaction) { Object resource = transaction.getResource(RESOURCE_KEY); ConcurrentMap<Application, URI> map = null; if (resource == null) { map = new ConcurrentHashMap<>(); resource = transaction.putResourceIfAbsent(RESOURCE_KEY, map); } return resource == null ? map : ConcurrentMap.class.cast(resource); }
@Override public void registerInterposedSynchronization(Synchronization sync) throws IllegalStateException { try { AbstractTransaction tx = ContextTransactionManager.getInstance().getTransaction(); JCAOrderedLastSynchronizationList jcaOrderedLastSynchronization = (JCAOrderedLastSynchronizationList) tx.getResource(key); if (jcaOrderedLastSynchronization == null) { final ContextTransactionSynchronizationRegistry tsr = ContextTransactionSynchronizationRegistry.getInstance(); synchronized (key) { jcaOrderedLastSynchronization = (JCAOrderedLastSynchronizationList) tx.getResource(key); if (jcaOrderedLastSynchronization == null) { jcaOrderedLastSynchronization = new JCAOrderedLastSynchronizationList(); tx.putResource(key, jcaOrderedLastSynchronization); tsr.registerInterposedSynchronization(jcaOrderedLastSynchronization); } } } jcaOrderedLastSynchronization.registerInterposedSynchronization(sync); } catch (SystemException e) { throw new IllegalStateException(e); } }
private int safeGetStatus(final AbstractTransaction tx) { try { return tx.getStatus(); } catch (SystemException e) { return Status.STATUS_UNKNOWN; } }
public void beforeCompletion() { try { if (importBacking()) try { sync.beforeCompletion(); } finally { unimportBacking(); } else { performConsumer(Synchronization::beforeCompletion, sync); } } catch (SystemException e) { throw new SynchronizationException(e); } }
@SuppressWarnings("unchecked") void addRollbackExceptions(Exception ex) { List<Throwable> list = (List<Throwable>) getResource(RB_EX_KEY); if (list != null) { for (Throwable throwable : list) { ex.addSuppressed(throwable); } } }
public void start(final StartContext context) throws StartException { final UserTransactionRegistry registry = registryInjector.getValue(); LocalTransactionContext.getCurrent().registerCreationListener((txn, createdBy) -> { if (createdBy == CreationListener.CreatedBy.USER_TRANSACTION) { if (WildFlySecurityManager.isChecking()) { AccessController.doPrivileged((PrivilegedAction<Void>) () -> { txn.registerAssociationListener(new AssociationListener() { private final AtomicBoolean first = new AtomicBoolean(); public void associationChanged(final AbstractTransaction t, final boolean a) { if (a && first.compareAndSet(false, true)) registry.userTransactionStarted(); } }); return null; }); } else { txn.registerAssociationListener(new AssociationListener() { private final AtomicBoolean first = new AtomicBoolean(); public void associationChanged(final AbstractTransaction t, final boolean a) { if (a && first.compareAndSet(false, true)) registry.userTransactionStarted(); } }); } } }); }
public void putResource(final Object key, final Object value) throws IllegalStateException { final AbstractTransaction transaction = ContextTransactionManager.getInstance().getStateRef().get().transaction; if (transaction == null) { throw Log.log.noTransaction(); } transaction.putResource(key, value); } }
public <T, E extends Exception> void performConsumer(ExceptionConsumer<T, E> consumer, T param) throws E, SystemException { performConsumer(ExceptionConsumer::accept, consumer, param); }
public void commit() throws RollbackException, HeuristicMixedException, HeuristicRollbackException, SecurityException, IllegalStateException, SystemException { final State state = stateRef.get(); try { if (state.transaction == null) { throw Log.log.noTransaction(); } state.transaction.commitAndDissociate(); } finally { state.transaction = null; } }
public boolean getRollbackOnly() throws IllegalStateException { final AbstractTransaction transaction = ContextTransactionManager.getInstance().getStateRef().get().transaction; if (transaction == null) { throw Log.log.noTransaction(); } return transaction.getRollbackOnly(); }
public Object getTransactionKey() { final AbstractTransaction transaction = ContextTransactionManager.getInstance().getStateRef().get().transaction; return transaction == null ? null : transaction.getKey(); }
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); } } }
public Object getResource(final Object key) throws IllegalStateException { final AbstractTransaction transaction = ContextTransactionManager.getInstance().getStateRef().get().transaction; if (transaction == null) { throw Log.log.noTransaction(); } return transaction.getResource(key); }
public static void registerSynchronization(EntityManager entityManager, String puScopedName, TransactionSynchronizationRegistry tsr, TransactionManager transactionManager) { SessionSynchronization sessionSynchronization = new SessionSynchronization(entityManager, puScopedName); tsr.registerInterposedSynchronization(sessionSynchronization); final AbstractTransaction transaction = ((ContextTransactionManager) transactionManager).getTransaction(); doPrivileged((PrivilegedAction<Void>) () -> { transaction.registerAssociationListener(sessionSynchronization); return null; }); }
public void putResource(final Object key, final Object value) throws IllegalStateException { final AbstractTransaction transaction = ContextTransactionManager.getInstance().getStateRef().get().transaction; if (transaction == null) { throw Log.log.noTransaction(); } transaction.putResource(key, value); } }
public <E extends Exception> void performAction(ExceptionRunnable<E> action) throws E, SystemException { performConsumer((ExceptionConsumer<ExceptionRunnable<E>, E>) ExceptionRunnable::run, action); }
public void commit() throws RollbackException, HeuristicMixedException, HeuristicRollbackException, SecurityException, IllegalStateException, SystemException { final State state = stateRef.get(); try { if (state.transaction == null) { throw Log.log.noTransaction(); } state.transaction.commitAndDissociate(); } finally { state.transaction = null; } }
public boolean getRollbackOnly() throws IllegalStateException { final AbstractTransaction transaction = ContextTransactionManager.getInstance().getStateRef().get().transaction; if (transaction == null) { throw Log.log.noTransaction(); } return transaction.getRollbackOnly(); }
public Object getTransactionKey() { final AbstractTransaction transaction = ContextTransactionManager.getInstance().getStateRef().get().transaction; return transaction == null ? null : transaction.getKey(); }
@SuppressWarnings("unchecked") public void setRollbackOnly() throws IllegalStateException, SystemException { List<Throwable> list = (List<Throwable>) getResource(RB_EX_KEY); if (list == null) { List<Throwable> appearing = (List<Throwable>) putResourceIfAbsent(RB_EX_KEY, list = new ArrayList<>()); if (appearing != null) { list = appearing; } } synchronized (list) { list.add(Log.log.markedRollbackOnly()); } }