BaseWebServiceTransactionFilter.java

/*
    This file is part of Cyclos (www.cyclos.org).
    A project of the Social Trade Organisation (www.socialtrade.org).

    Cyclos is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    Cyclos is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Cyclos; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

 */
package nl.strohalm.cyclos.http;

import java.io.IOException;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import nl.strohalm.cyclos.annotations.Inject;
import nl.strohalm.cyclos.exceptions.ApplicationException;
import nl.strohalm.cyclos.utils.TransactionHelper;
import nl.strohalm.cyclos.utils.access.LoggedUser;
import nl.strohalm.cyclos.utils.transaction.CurrentTransactionData;
import nl.strohalm.cyclos.utils.transaction.TransactionEndListener;
import nl.strohalm.cyclos.webservices.WebServiceContext;

import org.apache.commons.lang.exception.NestableRuntimeException;
import org.apache.commons.logging.Log;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;

/**
 * Base filter for web services transaction management
 * @author luis
 */
public abstract class BaseWebServiceTransactionFilter extends OncePerRequestFilter {

    protected TransactionHelper transactionHelper;
    protected Log               log = getLog();

    @Inject
    public void setTransactionHelper(final TransactionHelper transactionHelper) {
        this.transactionHelper = transactionHelper;
    }

    /**
     * Indicates whether the response state should be applied on transaction rollback as well
     */
    protected abstract boolean applyResponseStateOnRollback();

    @Override
    protected void execute(final HttpServletRequest request, final HttpServletResponse response, final FilterChain chain) throws IOException, ServletException {
        // Run the request in a new transaction
        try {
            transactionHelper.runInCurrentThread(new TransactionCallbackWithoutResult() {
                @Override
                protected void doInTransactionWithoutResult(final TransactionStatus status) {
                    // When debug is enabled, log the transaction begin and add a listener for transaction end log
                    prepareDebugLog();

                    // Execute the workflow
                    try {
                        onBeforeRunInTransaction(request, response);
                        doRunInTransaction(request, response, chain, status);
                    } catch (final Throwable t) {
                        try {
                            onError(request, response, t);
                        } catch (final IOException e) {
                            throw new NestableRuntimeException(e);
                        }
                    } finally {
                        try {
                            onTransactionEnd(request, response);
                        } catch (final IOException e) {
                            throw new NestableRuntimeException(e);
                        }
                    }
                }
            });
        } catch (final NestableRuntimeException e) {
            final Throwable cause = e.getCause();
            if (cause instanceof IOException) {
                throw (IOException) cause;
            }
            if (cause instanceof ServletException) {
                throw (ServletException) cause;
            }
            throw e;
        } finally {
            // Cleanup the thread locals
            WebServiceContext.cleanup();
            LoggedUser.cleanup();
        }
    }

    /**
     * Returns the logger
     */
    protected abstract Log getLog();

    /**
     * Returns the service name, which is used on logs
     */
    protected abstract String getServiceName();

    /**
     * Should be implemented in order to determine whether silenced errors from services will be rethrown
     */
    protected abstract boolean handleSilencedErrors();

    /**
     * Callback invoked before starting the transaction
     */
    protected void onBeforeRunInTransaction(final HttpServletRequest request, final HttpServletResponse response) throws IOException {
    }

    /**
     * Callback invoked when the processing results in error
     */
    protected void onError(final HttpServletRequest request, final HttpServletResponse response, final Throwable t) throws IOException {
    }

    /**
     * Callback invoked when the transaction has ended
     */
    protected void onTransactionEnd(final HttpServletRequest request, final HttpServletResponse response) throws IOException {
    }

    /**
     * Runs the filter chain inside a transaction
     */
    private void doRunInTransaction(final HttpServletRequest request, final HttpServletResponse servletResponse, final FilterChain chain, final TransactionStatus status) throws Throwable {
        try {
            // As both web services implementations (CXF for SOAP and Jackson for REST) manually flushes the response before we have the time to end
            // the transaction, we must use a custom response wrapper, which never flushes the buffer until we really want it
            final ResettableHttpServletResponse response = new ResettableHttpServletResponse(servletResponse);

            // Apply the response state after end
            CurrentTransactionData.addTransactionEndListener(new TransactionEndListener() {
                @Override
                protected void onTransactionEnd(final boolean commit) {
                    if (commit || applyResponseStateOnRollback()) {
                        response.applyState();
                    }
                }
            });

            // Process the filter chain
            chain.doFilter(request, response);

            // Handle silenced errors
            final Throwable error = CurrentTransactionData.getError();
            final Integer sc = response.getStatus();
            if (error != null && (sc == null || sc == HttpServletResponse.SC_OK)) {
                throw error;
            }

        } catch (final ApplicationException e) {
            if (e.isShouldRollback()) {
                status.setRollbackOnly();
            }
            if (handleSilencedErrors()) {
                throw e;
            }
        } catch (final Throwable t) {
            status.setRollbackOnly();
            if (handleSilencedErrors()) {
                throw t;
            }
        }
    }

    /**
     * Both logs the transaction begin and adds a transaction end listener to log commits / rollbacks. No-op if log debug is not enabled.
     */
    private void prepareDebugLog() {
        if (log.isDebugEnabled()) {
            log.debug("Running " + getServiceName() + " in a new transaction");
            CurrentTransactionData.addTransactionEndListener(new TransactionEndListener() {
                @Override
                protected void onTransactionEnd(final boolean commit) {
                    if (commit) {
                        log.debug("Committed " + getServiceName() + " transaction");
                    } else {
                        log.debug("Rolled back " + getServiceName() + " transaction");
                    }
                }
            });
        }
    }

}