Java tutorial
/* 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.struts; import java.io.IOException; import java.sql.Connection; import java.sql.SQLException; import java.util.HashSet; import java.util.Set; import javax.servlet.RequestDispatcher; import javax.servlet.ServletException; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpSession; import nl.strohalm.cyclos.annotations.Inject; import nl.strohalm.cyclos.entities.exceptions.LockingException; import nl.strohalm.cyclos.entities.settings.events.LocalSettingsChangeListener; import nl.strohalm.cyclos.exceptions.ApplicationException; import nl.strohalm.cyclos.http.ResettableHttpServletRequest; //import nl.strohalm.cyclos.http.ResettableHttpServletRequest; import nl.strohalm.cyclos.http.ResettableHttpServletResponse; import nl.strohalm.cyclos.services.access.exceptions.SystemOfflineException; import nl.strohalm.cyclos.services.settings.SettingsService; import nl.strohalm.cyclos.utils.ActionHelper; import nl.strohalm.cyclos.utils.DataIteratorHelper; import nl.strohalm.cyclos.utils.ExceptionHelper; import nl.strohalm.cyclos.utils.RequestHelper; import nl.strohalm.cyclos.utils.SpringHelper; import nl.strohalm.cyclos.utils.access.LoggedUser; import nl.strohalm.cyclos.utils.logging.LoggingHandler; import nl.strohalm.cyclos.utils.logging.TraceLogDTO; import nl.strohalm.cyclos.utils.transaction.CurrentTransactionData; import org.apache.commons.lang.StringUtils; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.struts.action.Action; import org.apache.struts.action.ActionForm; import org.apache.struts.action.ActionForward; import org.apache.struts.action.ActionMapping; import org.apache.struts.action.ActionServlet; import org.apache.struts.action.SecureTilesRequestProcessor; import org.apache.struts.config.ForwardConfig; import org.apache.struts.config.ModuleConfig; import org.hibernate.FlushMode; import org.hibernate.Session; import org.hibernate.Transaction; import org.hibernate.connection.ConnectionProvider; import org.hibernate.engine.SessionFactoryImplementor; import org.springframework.orm.hibernate3.SessionHolder; import org.springframework.transaction.support.TransactionSynchronizationManager; /** * Custom struts request processor. Among other things, we control the DB transactions here, opening a read-write transaction for action execution * @author luis */ public class CyclosRequestProcessor extends SecureTilesRequestProcessor { public static class ExecutionResult { private boolean commit; private boolean errorWasSilenced; private boolean hasWrite; private boolean traceLog; private boolean longTransaction; private Throwable error; private ActionForward forward; public Throwable getError() { return error; } public ActionForward getForward() { return forward; } public boolean isCommit() { return commit; } public boolean isErrorWasSilenced() { return errorWasSilenced; } public boolean isHasWrite() { return hasWrite; } public boolean isLongTransaction() { return longTransaction; } public boolean isTraceLog() { return traceLog; } } public static final String EXECUTION_RESULT_KEY = "cyclos.executionResult"; public static final String NO_TRANSACTION_KEY = "cyclos.noTransactionManagement"; private static final Log LOG = LogFactory.getLog(CyclosRequestProcessor.class); private SettingsService settingsService; private LoggingHandler loggingHandler; private SessionFactoryImplementor sessionFactory; private ConnectionProvider connectionProvider; private ActionHelper actionHelper; public SettingsService getSettingsService() { return settingsService; } @Override public void init(final ActionServlet servlet, final ModuleConfig moduleConfig) throws ServletException { super.init(servlet, moduleConfig); SpringHelper.injectBeans(servlet.getServletContext(), this); final CyclosControllerConfig config = (CyclosControllerConfig) moduleConfig.getControllerConfig(); settingsService.addListener(config); config.initialize(settingsService.getLocalSettings()); } @Override public void process(final HttpServletRequest request, final HttpServletResponse response) throws IOException, ServletException { try { request.setAttribute(EXECUTION_RESULT_KEY, new ExecutionResult()); super.process(request, response); } catch (final Exception e) { if (e instanceof IOException) { throw (IOException) e; } else if (e instanceof ServletException) { throw (ServletException) e; } else { throw new RuntimeException(e); } } finally { cleanUpTransaction(request); } } @Inject public void setActionHelper(final ActionHelper actionHelper) { this.actionHelper = actionHelper; } @Inject public void setLoggingHandler(final LoggingHandler loggingHandler) { this.loggingHandler = loggingHandler; } @Inject public void setSessionFactory(final SessionFactoryImplementor sessionFactory) { this.sessionFactory = sessionFactory; connectionProvider = sessionFactory.getConnectionProvider(); } @Inject public void setSettingsService(final SettingsService settingsService) { this.settingsService = settingsService; } /** * Override action creation to inject spring beans */ @Override protected Action processActionCreate(final HttpServletRequest request, final HttpServletResponse response, final ActionMapping actionMapping) throws IOException { synchronized (actions) { Action action = (Action) actions.get(actionMapping.getType()); if (action != null) { return action; } else { action = super.processActionCreate(request, response, actionMapping); if (action == null) { return null; } // Register the action as listener if (action instanceof LocalSettingsChangeListener) { settingsService.addListener((LocalSettingsChangeListener) action); } // Inject the required beans try { SpringHelper.injectBeans(getServletContext(), action); } catch (final Exception e) { // we must remove the already added action instance (by super.processActionCreate(...)) actions.remove(actionMapping.getType()); LOG.error("Error injecting beans on " + action, e); throw new IllegalStateException(e); } return action; } } } /** * Override form creation to remove the form from session if the request was triggered by the menu */ @Override @SuppressWarnings("unchecked") protected ActionForm processActionForm(final HttpServletRequest request, final HttpServletResponse response, final ActionMapping actionMapping) { final HttpSession session = request.getSession(); if (StringUtils.isEmpty(actionMapping.getName())) { return null; } if (RequestHelper.isFromMenu(request)) { session.removeAttribute(actionMapping.getName()); } // Add form to session final ActionForm form = super.processActionForm(request, response, actionMapping); if ("session".equals(actionMapping.getScope())) { Set<String> sessionForms = (Set<String>) session.getAttribute("sessionForms"); if (sessionForms == null) { sessionForms = new HashSet<String>(); session.setAttribute("sessionForms", sessionForms); } sessionForms.add(actionMapping.getName()); } return form; } /** * Here is where the actual action will be invoked. Before it, we open a read-write DB transaction. */ @Override protected ActionForward processActionPerform(final HttpServletRequest request, final HttpServletResponse response, final Action action, final ActionForm form, final ActionMapping mapping) throws IOException, ServletException { // Clean previous session stored forms if (RequestHelper.isFromMenu(request)) { cleanSessionForms(request, form); } // The main processing happens inside a loop, because we need to retry the main execution after a locking exception / deadlock final ResettableHttpServletRequest resetableRequest = new ResettableHttpServletRequest(request); final ResettableHttpServletResponse resetableResponse = new ResettableHttpServletResponse(response); while (true) { try { final ExecutionResult result = executeAction(resetableRequest, resetableResponse, action, form, mapping); // Apply the state resetableRequest.applyState(); resetableResponse.applyState(); return result.forward; } catch (final LockingException e) { // Retry the transaction, resetting the state resetableRequest.resetState(); resetableResponse.resetState(); logDebug(request, "Locking error - re-executing action"); } catch (final SystemOfflineException e) { return ActionHelper.sendError(mapping, request, response, "error.systemOffline"); } } } /** * If the given {@link ForwardConfig} will actually include something (probably a JSP), open a new read-only transaction, so lazy-loading and data * iteration will work */ //@Override protected void processForwardConfig(final HttpServletRequest request, final HttpServletResponse response, final ForwardConfig forward) throws IOException, ServletException { final ExecutionResult result = (ExecutionResult) request.getAttribute(EXECUTION_RESULT_KEY); final boolean isInclude = forward != null && !forward.getRedirect(); final boolean needsReadOnlyConnection = isInclude && !result.longTransaction; if (needsReadOnlyConnection) { // When needed, open a new read-only connection for the include openReadOnlyConnection(request); } // The top-most invocation will manage transaction. Any includes won't final boolean managesTransaction = !noTransaction(request); if (managesTransaction) { request.setAttribute(NO_TRANSACTION_KEY, true); } try { super.processForwardConfig(request, response, forward); } catch (final IllegalStateException e) { LOG.warn("Error processing the forward to " + forward.getPath()); } finally { if (managesTransaction) { // Remove the attribute, otherwise, the top-most invocations of commitOrRollbackTransaction() or rollbackTransaction() will do nothing request.removeAttribute(NO_TRANSACTION_KEY); } if (result.longTransaction) { // Close the long running read-write connection result.commit = false; commitOrRollbackTransaction(request); } else if (needsReadOnlyConnection) { rollbackReadOnlyConnection(request); } } } //@Override protected HttpServletRequest processMultipart(final HttpServletRequest request) { final HttpServletRequest multipartRequest = super.processMultipart(request); if (multipartRequest != request) { request.setAttribute("multipartRequest", multipartRequest); } return multipartRequest; } // @Override protected void processPopulate(final HttpServletRequest request, final HttpServletResponse response, final ActionForm form, final ActionMapping mapping) throws ServletException { try { super.processPopulate(request, response, form, mapping); } catch (final Exception e) { LOG.error("Error populating " + form + " in " + mapping.getPath(), e); request.getSession().setAttribute("errorKey", "error.validation"); final RequestDispatcher rd = request.getRequestDispatcher("/do/error"); try { rd.forward(request, response); } catch (final IOException e1) { LOG.error("Error while trying to forward to error page", e1); } } } // @SuppressWarnings("unchecked") private void cleanSessionForms(final HttpServletRequest request, final ActionForm form) { final HttpSession session = request.getSession(); final Set<String> sessionForms = (Set<String>) session.getAttribute("sessionForms"); if (sessionForms != null) { for (final String name : sessionForms) { final ActionForm currentForm = (ActionForm) session.getAttribute(name); if (currentForm != form) { session.removeAttribute(name); } } } } private void cleanUpTransaction(final HttpServletRequest request) { if (noTransaction(request)) { return; } logDebug(request, "Cleaning up transaction"); // Close any open iterators DataIteratorHelper.closeOpenIterators(); // Close the session final SessionHolder holder = (SessionHolder) TransactionSynchronizationManager.getResource(sessionFactory); if (holder != null) { try { final Session session = holder.getSession(); if (session.isOpen()) { session.close(); } } catch (final Exception e) { LOG.error("Error closing Hibernate session", e); } TransactionSynchronizationManager.unbindResourceIfPossible(sessionFactory); } // Close the connection final Connection connection = (Connection) TransactionSynchronizationManager .getResource(connectionProvider); if (connection != null) { try { connectionProvider.closeConnection(connection); } catch (final Exception e) { LOG.error("Error closing database connection", e); } TransactionSynchronizationManager.unbindResourceIfPossible(connectionProvider); } // Cleanup the Spring transaction data TransactionSynchronizationManager.setCurrentTransactionReadOnly(false); TransactionSynchronizationManager.setActualTransactionActive(false); // Cleanup the current transaction data CurrentTransactionData.cleanup(); request.removeAttribute(EXECUTION_RESULT_KEY); } private void commitOrRollbackTransaction(final HttpServletRequest request) throws IOException, ServletException { if (noTransaction(request)) { return; } final ExecutionResult result = (ExecutionResult) request.getAttribute(EXECUTION_RESULT_KEY); final SessionHolder sessionHolder = getSessionHolder(); // Commit or rollback the transaction boolean runCommitListeners = false; boolean lockingException = false; if (result.commit) { logDebug(request, "Committing transaction"); runCommitListeners = true; // Marked as commit - should run commit listeners try { sessionHolder.getTransaction().commit(); } catch (final Throwable t) { // In case of locking exceptions, we must make sure the correct exception type is returned, so the transaction will be retried lockingException = ExceptionHelper.isLockingException(t); result.error = t; } } else { if (result.error == null && !result.hasWrite) { // Transaction was semantically a commit, so, the commit listeners should run. // However, as there where no writes the transaction will be rolled back runCommitListeners = true; logDebug(request, "Nothing written to database. Rolling-back transaction"); } else { logDebug(request, "Rolling-back transaction"); } sessionHolder.getTransaction().rollback(); } // Disconnect the session sessionHolder.getSession().disconnect(); if (lockingException) { // There was a locking exception - throw it now, so the transaction will be retried cleanUpTransaction(request); throw new LockingException(); } // Unbind the session holder, so that listeners which should open a new transaction on this same thread won't be messed up TransactionSynchronizationManager.unbindResourceIfPossible(sessionFactory); // Run the transaction listener CurrentTransactionData.detachListeners().runListeners(runCommitListeners); // Bind the session holder again TransactionSynchronizationManager.bindResource(sessionFactory, sessionHolder); // Log the execution if a regular user is logged in and this is not an AJAX request if (result.traceLog) { traceLog(request, result.error, result.commit); } // The resulting error was not silenced (i.e, by the BaseAction's try / catch. Log and rethrow if (result.error != null && !result.errorWasSilenced) { actionHelper.generateLog(request, servlet.getServletContext(), result.error); ActionHelper.throwException(result.error); } } private ExecutionResult doExecuteAction(final HttpServletRequest request, final HttpServletResponse response, final Action action, final ActionForm form, final ActionMapping mapping) { final ExecutionResult result = (ExecutionResult) request.getAttribute(EXECUTION_RESULT_KEY); try { result.forward = super.processActionPerform(request, response, action, form, mapping); // Get data from CurrentTransactionData result.error = CurrentTransactionData.getError(); result.errorWasSilenced = result.error != null; result.longTransaction = DataIteratorHelper.hasOpenIteratorsRequiringOpenConnection(); if (result.error == null) { final SessionHolder holder = getSessionHolder(); holder.getSession().flush(); } result.hasWrite = CurrentTransactionData.hasWrite(); if (result.error instanceof ApplicationException) { // When there's an ApplicationError, we can still commit, depending on the flag result.commit = result.hasWrite && !((ApplicationException) result.error).isShouldRollback(); } else { // The general case: commit if there are no errors result.commit = result.hasWrite && !result.errorWasSilenced; } } catch (final ApplicationException e) { result.commit = e.isShouldRollback() ? false : true; result.error = e; } catch (final Throwable e) { result.commit = false; result.error = e; } result.traceLog = generateTraceLog(request); return result; } private ExecutionResult executeAction(final HttpServletRequest request, final HttpServletResponse response, final Action action, final ActionForm form, final ActionMapping mapping) throws IOException, ServletException { // Open a new read-write connection try { openReadWriteConnection(request); } catch (final Exception e) { throw new SystemOfflineException(); } // Execute the actual action final ExecutionResult result = doExecuteAction(request, response, action, form, mapping); // Commit or rollback transaction if the current request does not need a long transaction if (!result.longTransaction) { commitOrRollbackTransaction(request); } else { logDebug(request, "Keeping connection open because there are open iterators"); } return result; } private boolean generateTraceLog(final HttpServletRequest request) { final String uri = request.getRequestURI(); return LoggedUser.getAccessType() == LoggedUser.AccessType.USER && !RequestHelper.isAjax(request) && !uri.endsWith("/login") && !uri.endsWith("/logout"); } private SessionHolder getSessionHolder() { return (SessionHolder) TransactionSynchronizationManager.getResource(sessionFactory); } private void logDebug(final HttpServletRequest request, final String message) { if (LOG.isDebugEnabled()) { final String method = RequestHelper.isValidation(request) ? "VALIDATION" : request.getMethod(); LOG.debug(String.format("%s (%s): %s", request.getRequestURI(), method, message)); } } private boolean noTransaction(final HttpServletRequest request) { return Boolean.TRUE.equals(request.getAttribute(NO_TRANSACTION_KEY)); } private void openReadOnlyConnection(final HttpServletRequest request) { if (noTransaction(request)) { return; } logDebug(request, "Opening read-only transaction for include"); final Connection connection = (Connection) TransactionSynchronizationManager .getResource(connectionProvider); final SessionHolder holder = (SessionHolder) TransactionSynchronizationManager.getResource(sessionFactory); final Session session = holder.getSession(); session.setFlushMode(FlushMode.MANUAL); session.setDefaultReadOnly(true); session.reconnect(connection); TransactionSynchronizationManager.setCurrentTransactionReadOnly(true); } private void openReadWriteConnection(final HttpServletRequest request) throws IOException, ServletException { if (noTransaction(request)) { return; } logDebug(request, "Opening a new read-write transaction"); // Open a read-write transaction Connection connection = null; Session session = null; SessionHolder holder = null; Transaction transaction = null; try { connection = connectionProvider.getConnection(); TransactionSynchronizationManager.bindResource(connectionProvider, connection); session = sessionFactory.openSession(connection); holder = new SessionHolder(session); transaction = session.beginTransaction(); holder.setTransaction(transaction); TransactionSynchronizationManager.bindResource(sessionFactory, holder); holder.setSynchronizedWithTransaction(true); TransactionSynchronizationManager.setActualTransactionActive(true); TransactionSynchronizationManager.setCurrentTransactionReadOnly(false); } catch (final Exception e) { if (connection != null) { try { connectionProvider.closeConnection(connection); } catch (final SQLException e1) { LOG.warn("Error closing connection", e1); } finally { TransactionSynchronizationManager.unbindResourceIfPossible(connectionProvider); TransactionSynchronizationManager.unbindResourceIfPossible(sessionFactory); } } LOG.error("Couldn't open a transaction", e); ActionHelper.throwException(e); } } private void rollbackReadOnlyConnection(final HttpServletRequest request) { if (noTransaction(request)) { return; } final Connection connection = (Connection) TransactionSynchronizationManager .getResource(connectionProvider); try { logDebug(request, "Rolling back read-only transaction"); connection.rollback(); } catch (final SQLException e) { throw new IllegalStateException(e); } } private void traceLog(final HttpServletRequest request, final Throwable error, final boolean hasWrite) { final HttpServletRequest multipartRequest = (HttpServletRequest) request.getAttribute("multipartRequest"); final HttpServletRequest req = multipartRequest == null ? request : multipartRequest; final TraceLogDTO params = new TraceLogDTO(); params.setUser(LoggedUser.user()); params.setRemoteAddress(req.getRemoteAddr()); params.setRequestMethod(req.getMethod()); params.setPath(req.getRequestURI()); params.setParameters(ActionHelper.getParameterMap(req)); final HttpSession session = req.getSession(false); params.setSessionId(session == null ? null : session.getId()); params.setError(error); params.setHasDatabaseWrites(hasWrite); loggingHandler.trace(params); } }