Example usage for org.springframework.transaction.reactive TransactionSynchronization STATUS_ROLLED_BACK

Introduction

In this page you can find the example usage for org.springframework.transaction.reactive TransactionSynchronization STATUS_ROLLED_BACK.

Prototype

int STATUS_ROLLED_BACK

To view the source code for org.springframework.transaction.reactive TransactionSynchronization STATUS_ROLLED_BACK.

Click Source Link

Document

Completion status in case of proper rollback.

Usage

From source file:org.springframework.transaction.reactive.AbstractReactiveTransactionManager.java

/**
 * Process an actual commit./*from ww w .jav  a  2  s.c o  m*/
 * Rollback-only flags have already been checked and applied.
 * @param synchronizationManager the synchronization manager bound to the current transaction
 * @param status object representing the transaction
 * @throws TransactionException in case of commit failure
 */
private Mono<Void> processCommit(TransactionSynchronizationManager synchronizationManager,
        GenericReactiveTransaction status) throws TransactionException {

    AtomicBoolean beforeCompletionInvoked = new AtomicBoolean(false);

    Mono<Object> commit = prepareForCommit(synchronizationManager, status)
            .then(triggerBeforeCommit(synchronizationManager, status))
            .then(triggerBeforeCompletion(synchronizationManager, status)).then(Mono.defer(() -> {
                beforeCompletionInvoked.set(true);
                if (status.isNewTransaction()) {
                    if (status.isDebug()) {
                        logger.debug("Initiating transaction commit");
                    }
                    return doCommit(synchronizationManager, status);
                }
                return Mono.empty();
            })).then(Mono.empty().onErrorResume(ex -> {
                Mono<Object> propagateException = Mono.error(ex);
                // Store result in a local variable in order to appease the
                // Eclipse compiler with regard to inferred generics.
                Mono<Object> result = propagateException;
                if (ErrorPredicates.UNEXPECTED_ROLLBACK.test(ex)) {
                    result = triggerAfterCompletion(synchronizationManager, status,
                            TransactionSynchronization.STATUS_ROLLED_BACK).then(propagateException);
                } else if (ErrorPredicates.TRANSACTION_EXCEPTION.test(ex)) {
                    result = triggerAfterCompletion(synchronizationManager, status,
                            TransactionSynchronization.STATUS_UNKNOWN).then(propagateException);
                } else if (ErrorPredicates.RUNTIME_OR_ERROR.test(ex)) {
                    Mono<Void> mono;
                    if (!beforeCompletionInvoked.get()) {
                        mono = triggerBeforeCompletion(synchronizationManager, status);
                    } else {
                        mono = Mono.empty();
                    }
                    result = mono.then(doRollbackOnCommitException(synchronizationManager, status, ex))
                            .then(propagateException);
                }

                return result;
            }))
            .then(Mono.defer(() -> triggerAfterCommit(synchronizationManager, status)
                    .onErrorResume(ex -> triggerAfterCompletion(synchronizationManager, status,
                            TransactionSynchronization.STATUS_COMMITTED).then(Mono.error(ex)))
                    .then(triggerAfterCompletion(synchronizationManager, status,
                            TransactionSynchronization.STATUS_COMMITTED))));

    return commit
            .onErrorResume(ex -> cleanupAfterCompletion(synchronizationManager, status).then(Mono.error(ex)))
            .then(cleanupAfterCompletion(synchronizationManager, status));
}

---

From source file:org.springframework.transaction.reactive.AbstractReactiveTransactionManager.java

/**
 * Process an actual rollback./*from   www .j a va 2  s. c  om*/
 * The completed flag has already been checked.
 * @param synchronizationManager the synchronization manager bound to the current transaction
 * @param status object representing the transaction
 * @throws TransactionException in case of rollback failure
 */
private Mono<Void> processRollback(TransactionSynchronizationManager synchronizationManager,
        GenericReactiveTransaction status) {

    return triggerBeforeCompletion(synchronizationManager, status).then(Mono.defer(() -> {
        if (status.isNewTransaction()) {
            if (status.isDebug()) {
                logger.debug("Initiating transaction rollback");
            }
            return doRollback(synchronizationManager, status);
        } else {
            Mono<Void> beforeCompletion = Mono.empty();
            // Participating in larger transaction
            if (status.hasTransaction()) {
                if (status.isDebug()) {
                    logger.debug(
                            "Participating transaction failed - marking existing transaction as rollback-only");
                }
                beforeCompletion = doSetRollbackOnly(synchronizationManager, status);
            } else {
                logger.debug("Should roll back transaction but cannot - no transaction available");
            }
            return beforeCompletion;
        }
    })).onErrorResume(ErrorPredicates.RUNTIME_OR_ERROR,
            ex -> triggerAfterCompletion(synchronizationManager, status,
                    TransactionSynchronization.STATUS_UNKNOWN).then(Mono.error(ex)))
            .then(Mono.defer(() -> triggerAfterCompletion(synchronizationManager, status,
                    TransactionSynchronization.STATUS_ROLLED_BACK)))
            .onErrorResume(ex -> cleanupAfterCompletion(synchronizationManager, status).then(Mono.error(ex)))
            .then(cleanupAfterCompletion(synchronizationManager, status));
}

---

From source file:org.springframework.transaction.reactive.AbstractReactiveTransactionManager.java

/**
 * Invoke {@code doRollback}, handling rollback exceptions properly.
 * @param synchronizationManager the synchronization manager bound to the current transaction
 * @param status object representing the transaction
 * @param ex the thrown application exception or error
 * @throws TransactionException in case of rollback failure
 * @see #doRollback/*from  ww  w. j av  a2  s .com*/
 */
private Mono<Void> doRollbackOnCommitException(TransactionSynchronizationManager synchronizationManager,
        GenericReactiveTransaction status, Throwable ex) throws TransactionException {

    return Mono.defer(() -> {
        if (status.isNewTransaction()) {
            if (status.isDebug()) {
                logger.debug("Initiating transaction rollback after commit exception", ex);
            }
            return doRollback(synchronizationManager, status);
        } else if (status.hasTransaction()) {
            if (status.isDebug()) {
                logger.debug("Marking existing transaction as rollback-only after commit exception", ex);
            }
            return doSetRollbackOnly(synchronizationManager, status);
        }
        return Mono.empty();
    }).onErrorResume(ErrorPredicates.RUNTIME_OR_ERROR, rbex -> {
        logger.error("Commit exception overridden by rollback exception", ex);
        return triggerAfterCompletion(synchronizationManager, status, TransactionSynchronization.STATUS_UNKNOWN)
                .then(Mono.error(rbex));
    }).then(triggerAfterCompletion(synchronizationManager, status,
            TransactionSynchronization.STATUS_ROLLED_BACK));
}

---