Examples with TransactionManager com.arjuna.mw.wst11.TransactionManager used on opensource projects

Example 1 with TransactionManager

use of com.arjuna.mw.wst11.TransactionManager in project wildfly by wildfly.

the class ATSuperService method invokeWithCallName.

/**
     * Adding 2 participants - Volatile and Durable
     *
     * @param callName        call name works for differentiate several calls to the same webservice
     *                        if you don't want care pass null (or overloaded method :)
     * @param serviceCommands service commands that service will react on
     * @throws WrongStateException
     * @throws com.arjuna.wst.SystemException
     * @throws UnknownTransactionException
     * @throws SecurityException
     * @throws javax.transaction.SystemException
     * @throws IllegalStateException
     */
public void invokeWithCallName(String callName, ServiceCommand[] serviceCommands) throws TestApplicationException {
    log.infof("[AT SERVICE] web method invoke(%s) with eventLog %s", callName, eventLog);
    eventLog.foundEventLogName(callName);
    UserTransaction userTransaction;
    try {
        userTransaction = UserTransactionFactory.userTransaction();
        String transactionId = userTransaction.transactionIdentifier();
        log.debug("RestaurantServiceAT transaction id =" + transactionId);
        // Enlist the Durable Participant for this service
        TransactionManager transactionManager = TransactionManagerFactory.transactionManager();
        ATDurableParticipant durableParticipant = new ATDurableParticipant(serviceCommands, callName, eventLog, transactionId);
        log.trace("[SERVICE] Enlisting a Durable2PC participant into the AT");
        transactionManager.enlistForDurableTwoPhase(durableParticipant, "ATServiceDurable:" + new Uid().toString());
        // Enlist the Volatile Participant for this service
        ATVolatileParticipant volatileParticipant = new ATVolatileParticipant(serviceCommands, callName, eventLog, transactionId);
        log.trace("[SERVICE] Enlisting a VolatilePC participant into the AT");
        transactionManager.enlistForVolatileTwoPhase(volatileParticipant, "ATServiceVolatile:" + new Uid().toString());
    } catch (Exception e) {
        throw new RuntimeException("Error when enlisting participants", e);
    }
    if (ServiceCommand.isPresent(APPLICATION_EXCEPTION, serviceCommands)) {
        throw new TestApplicationException("Intentionally thrown Application Exception - service command was set to: " + APPLICATION_EXCEPTION);
    }
    if (ServiceCommand.isPresent(ROLLBACK_ONLY, serviceCommands)) {
        log.trace("Intentionally the service settings transaction to rollback only - service command was set to: " + ROLLBACK_ONLY);
        try {
            userTransaction.rollback();
        } catch (Exception e) {
            throw new RuntimeException("The rollback is not possible", e);
        }
    }
    // There will be some business logic here normally
    log.trace("|AT SERVICE] I'm working on nothing...");
}

Example 2 with TransactionManager

use of com.arjuna.mw.wst11.TransactionManager in project quickstart by wildfly.

the class RestaurantServiceATImpl method makeBooking.

/**
 * Book a number of seats in the restaurant. Enrols a Participant, then passes the call through to the business logic.
 */
@WebMethod
public void makeBooking() throws RestaurantException {
    System.out.println("[SERVICE] Restaurant service invoked to make a booking");
    String transactionId;
    try {
        // get the transaction ID associated with this thread
        transactionId = UserTransactionFactory.userTransaction().toString();
        // enlist the Participant for this service:
        RestaurantParticipant restaurantParticipant = new RestaurantParticipant(transactionId);
        TransactionManager transactionManager = TransactionManagerFactory.transactionManager();
        System.out.println("[SERVICE] Enlisting a Durable2PC participant into the AT");
        transactionManager.enlistForDurableTwoPhase(restaurantParticipant, "restaurantServiceAT:" + UUID.randomUUID());
    } catch (Exception e) {
        throw new RestaurantException("Error when enlisting participant", e);
    }
    // invoke the backend business logic:
    System.out.println("[SERVICE] Invoking the back-end business logic");
    mockRestaurantManager.makeBooking(transactionId);
}