* Copyright 2004 The Apache Software Foundation.

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

*     http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*

* $Header:$

*/

* The Page Flow extension of the Struts RequestProcessor, which contains callbacks that are invoked

* during processing of a request to the Struts action servlet.  This class is registered as the

* <strong>controller</strong> for all Struts modules derived from page flows.

*/

        extends TilesRequestProcessor

        implements Serializable, InternalConstants, PageFlowConstants

    private static int requestNumber = 0;

    private static final Logger _log = Logger.getInstance( PageFlowRequestProcessor.class );

    private static final String ACTION_OVERRIDE_PARAM_PREFIX = "actionOverride:";

    private static final int    ACTION_OVERRIDE_PARAM_PREFIX_LEN = ACTION_OVERRIDE_PARAM_PREFIX.length();

    private static final String SCHEME_UNSECURE = "http";

    private static final String SCHEME_SECURE = "https";

    private static final String REDIRECT_REQUEST_ATTRS_PREFIX = InternalConstants.ATTR_PREFIX + "requestAttrs:";

    private static final String REDIRECT_REQUEST_ATTRS_PARAM = "forceRedirect";

    private static final String FLOW_CONTROLLER_ACTION_CLASSNAME = FlowControllerAction.class.getName();

    private static final NullActionForm NULL_ACTION_FORM = new NullActionForm();

    private Map/*< String, Class >*/ _formBeanClasses = new HashMap/*< String, Class >*/();

    private Map/*< String, List< ActionMapping > >*/ _overloadedActions = new HashMap/*< String, List< ActionMapping > >*/();

    private ServletContainerAdapter _servletContainerAdapter;

    private Handlers _handlers;

    private FlowControllerFactory _flowControllerFactory;

    private LegacySettings _legacySettings;

    private InternalConcurrentHashMap/*< String, Class >*/ _pageServletClasses = new InternalConcurrentHashMap/*< String, Class >*/();

    private PageFlowPageFilter _pageServletFilter;

    protected Action processActionCreate( HttpServletRequest request, HttpServletResponse response,

                                          ActionMapping actionMapping )

        throws IOException

    {

        String className = actionMapping.getType();

        if ( className != null && className.equals( FLOW_CONTROLLER_ACTION_CLASSNAME ) )

        {

            FlowController fc = PageFlowRequestWrapper.get( request ).getCurrentFlowController();

            assert fc != null : "no FlowController for request " + request.getRequestURI();

            assert fc.getClass().getName().equals( actionMapping.getParameter() )

                    : "current page flow  type " + fc.getClass().getName() + " does not match type specified in "

                      + FLOW_CONTROLLER_ACTION_CLASSNAME + ": " + actionMapping.getParameter();

            Action action = new FlowControllerAction( fc );

            action.setServlet( servlet );

            return action;

        }

        return super.processActionCreate( request, response, actionMapping );

    }

    /**

     * Same as code in RequestUtils.createActionForm(), but doesn't try to get the form bean out of

     * the request/session (i.e., always creates a new one).

     */

    private ActionForm createActionForm( ActionMapping mapping, HttpServletRequest request )

    {

        String name = mapping.getName();

        assert name != null : mapping.getPath();

        if ( name == null ) return null;

        FormBeanConfig config = moduleConfig.findFormBeanConfig( name );

        ActionForm instance;

        //

        // Create the form bean.  There's special handling for dyna-form-beans.

        //

        if ( config.getDynamic() )

        {

            try

            {

                DynaActionFormClass dynaClass = DynaActionFormClass.createDynaActionFormClass( config );

                instance = ( ActionForm ) dynaClass.newInstance();

                ( ( DynaActionForm ) instance ).initialize( mapping );

                if ( _log.isDebugEnabled() )

                {

                    _log.debug( " Creating new DynaActionForm instance " + "of type '" + config.getType() + '\'' );

                }

            }

            catch ( Exception e )

            {

                _log.error( servlet.getInternal().getMessage( "formBean", config.getType() ), e );

                return null;

            }

        }

        else

        {

            try

            {

                instance = ( ActionForm ) InternalUtils.newReloadableInstance( config.getType(), getServletContext() );

                if ( _log.isDebugEnabled() )

                {

                    _log.debug( " Creating new ActionForm instance " + "of type '" + config.getType() + '\'' );

                }

            }

            catch ( Exception e )

            {

                _log.error( servlet.getInternal().getMessage( "formBean", config.getType() ), e );

                return null;

            }

        }

        instance.setServlet( servlet );

        return instance;

    }

    private Field getPageFlowScopedFormMember( ActionMapping mapping, HttpServletRequest request )

    {

        if ( mapping instanceof PageFlowActionMapping )

        {

            PageFlowActionMapping pfam = ( PageFlowActionMapping ) mapping;

            String formMember = pfam.getFormMember();

            try

            {

                if ( formMember != null )

                {

                    FlowController fc = PageFlowRequestWrapper.get( request ).getCurrentFlowController();

                    Field field = fc.getClass().getDeclaredField( formMember );

                    if ( ! Modifier.isPublic( field.getModifiers() ) ) field.setAccessible( true );

                    return field;

                }

            }

            catch ( Exception e )

            {

                _log.error( "Could not use page flow member " + formMember + " as the form bean.", e );

            }

        }

        return null;

    }

    protected ActionForm processActionForm( HttpServletRequest request, HttpServletResponse response,

                                            ActionMapping mapping )

    {

        //

        // See if we're using a pageflow-scoped form (a member variable in the current pageflow).

        //

        Field formMemberField = getPageFlowScopedFormMember( mapping, request );

        //

        // First look to see whether the input form was overridden in the request.

        // This happens when a pageflow action forwards to another pageflow,

        // whose begin action expects a form.  In this case, the form is already

        // constructed, and shouldn't be instantiated anew or populated from request

        // parameters.

        //

        ActionForm previousForm = InternalUtils.getForwardedFormBean( request, false );

        if ( previousForm != null )

        {

            //

            // If there was a forwarded form, and if this action specifies a pageflow-scoped form member,

            // set the member with this form.

            //

            if ( formMemberField != null )

            {

                try

                {

                    FlowController fc = PageFlowRequestWrapper.get( request ).getCurrentFlowController();

                    assert fc != null : "no FlowController in request " + request.getRequestURI();

                    formMemberField.set( fc, InternalUtils.unwrapFormBean(  previousForm ) );

                }

                catch ( IllegalAccessException e )

                {

                    _log.error( "Could not access page flow member " + formMemberField.getName()

                                  + " as the form bean.", e );

                }

            }

            //

            // Return the forwarded form.

            //

            previousForm.setServlet( servlet );

            return previousForm;

        }

        //

        // First see if the previous action put a pageflow-scoped form in the request.  If so, remove it;

        // we don't want a normal request-scoped action to use this pageflow-scoped form.

        //

        String pageFlowScopedFormName = PageFlowRequestWrapper.get( request ).getPageFlowScopedFormName();

        if ( pageFlowScopedFormName != null )

        {

            request.removeAttribute( pageFlowScopedFormName );

            PageFlowRequestWrapper.get( request ).setPageFlowScopedFormName( null );

        }

        //

        // If this action specifies a pageflow-scoped form member variable, use it.

        //

        if ( formMemberField != null )

        {

            try

            {

                FlowController fc = PageFlowRequestWrapper.get( request ).getCurrentFlowController();

                ActionForm form = InternalUtils.wrapFormBean( formMemberField.get( fc ) );

                if ( form == null ) // the pageflow hasn't filled the value yet

                {

                    form = createActionForm( mapping, request );

                    form.reset( mapping, request );

                    formMemberField.set( fc, InternalUtils.unwrapFormBean( form ) );

                }

                //

                // Store the form in the right place in the request, so Struts can see it.

                // But, mark a flag so we know to remove this on the next action request -- we don't

                // want this form used by another action unless that action uses the pageflow-scoped

                // form.

                //

                String formAttrName = mapping.getAttribute();

                request.setAttribute( formAttrName, form );

                PageFlowRequestWrapper.get( request ).setPageFlowScopedFormName( formAttrName );

                return form;

            }

            catch ( IllegalAccessException e )

            {

                _log.error( "Could not access page flow member " + formMemberField.getName() + " as the form bean.", e );

            }

        }

        ActionForm bean = super.processActionForm( request, response, mapping );

        if ( bean == null )

        {

            bean = InternalUtils.createActionForm( mapping, moduleConfig, servlet, getServletContext() );

        }

        return bean;

    }

    protected void processPopulate( HttpServletRequest request, HttpServletResponse response, ActionForm form,

                                    ActionMapping mapping )

        throws ServletException

    {

        //

        // If a previous action forwarded us a form, use that -- don't populate it from request parameters.

        //

        ActionForm previousForm = InternalUtils.getForwardedFormBean( request, true );

        if ( previousForm != null )

        {

            return;

        }

        if ( _log.isDebugEnabled() )

        {

            _log.debug( "Populating bean properties from this request" );

        }

        // struts does this

        if ( form != null )

        {

            form.setServlet( servlet );

            form.reset( mapping, request );

        }

        if ( mapping.getMultipartClass() != null )

        {

            request.setAttribute( Globals.MULTIPART_KEY, mapping.getMultipartClass() );

        }

        PageFlowRequestWrapper requestWrapper = PageFlowRequestWrapper.get( request );

        boolean alreadyCalledInRequest = requestWrapper.isProcessPopulateAlreadyCalled();

        if ( ! alreadyCalledInRequest ) requestWrapper.setProcessPopulateAlreadyCalled( true );

        //

        // If this is a forwarded request and the form-bean is null, don't call to ProcessPopulate.

        // We don't want to expose errors due to parameters from the original request, which won't

        // apply to a forwarded action that doesn't take a form.

        //

        if ( !alreadyCalledInRequest || form != null )

        {

            //

            // If this request was forwarded by a button-override of the main form action, then ensure that there are

            // no databinding errors when the override action does not use a form bean.

            //

            if ( form == null && requestWrapper.isForwardedByButton() ) form = NULL_ACTION_FORM;

            ProcessPopulate.populate( request, response, form, alreadyCalledInRequest );

        }

    }

    /**

     * The requested action can be overridden by a request parameter.  In this case, we parse the action from

     * the request parameter and forward to a URI constructed from it.

     *

     * @param request the current HttpServletRequest

     * @param response the current HttpServletResponse

     * @return <code>true</code> if the action was overridden by a request parameter, in which case the request

     *         was forwarded.

     * @throws IOException

     * @throws ServletException

     */

    protected boolean processActionOverride( HttpServletRequest request, HttpServletResponse response )

        throws IOException, ServletException

    {

        // Only make this check if this is an initial (non-forwarded) request.

        //

        // TODO: performance?

        //

        PageFlowRequestWrapper wrapper = PageFlowRequestWrapper.get( request );

        if ( ! wrapper.isForwardedByButton() && ! wrapper.isForwardedRequest() )

        {

            //

            // First, since we need access to request parameters here, process a multipart request

            // if that's what we have.  This puts the parameters (each in a MIME part) behind an

            // interface that makes them look like normal request parameters.

            //

            HttpServletRequest multipartAwareRequest = processMultipart( request );

            for ( Enumeration e = multipartAwareRequest.getParameterNames(); e.hasMoreElements(); )

            {

                String paramName = ( String ) e.nextElement();

                if ( paramName.startsWith( ACTION_OVERRIDE_PARAM_PREFIX ) )

                {

                    String actionPath = paramName.substring( ACTION_OVERRIDE_PARAM_PREFIX_LEN );

                    ServletContext servletContext = getServletContext();

                    String qualifiedAction = InternalUtils.qualifyAction( servletContext,actionPath );

                    actionPath = InternalUtils.createActionPath(request, qualifiedAction );

                    if ( _log.isDebugEnabled() )

                    {

                        _log.debug( "A request parameter overrode the action.  Forwarding to: " + actionPath );

                    }

                    wrapper.setForwardedByButton( true );

                    doForward( actionPath, request, response );

                    return true;

                }

            }

        }

        return false;

    }

    private void processInternal( HttpServletRequest request, HttpServletResponse response )

            throws IOException, ServletException

    {

        //

        // First wrap the request with an object that contains request-scoped values that our runtime uses.  This

        // is faster than sticking everything into attributes on the request (then basically reading from a HashMap).

        //

        request = PageFlowRequestWrapper.wrapRequest( request );

        String uri = InternalUtils.getDecodedServletPath( request );

        ServletContext servletContext = getServletContext();

        //

        // Allow the container to do a security check on forwarded requests, if that feature is enabled.

        //

        if ( LegacySettings.get( servletContext ).shouldDoSecureForwards()

             && PageFlowRequestWrapper.get( request ).isForwardedRequest() )

        {

            //

            // In some situations (namely, in scoped requests under portal), the initial

            // security check may not have been done for the request URI.  In this case, a redirect

            // to https may happen during checkSecurity().

            //

            if ( _servletContainerAdapter.doSecurityRedirect( uri, request, response ) )

            {

                if ( _log.isDebugEnabled() )

                {

                    _log.debug( "checkSecurity() caused a redirect.  Ending processing for this request "

                               + '(' + uri + ')' );

                }

                return;

            }

        }

        //

        // If we've come in on a forced redirect due to security constraints, look for request attrs

        // that we put into the session.

        //

        String hash = request.getParameter( REDIRECT_REQUEST_ATTRS_PARAM );

        if ( hash != null )

        {

            HttpSession session = request.getSession( false );

            if ( session != null )

            {

                String carryoverAttrName = makeRedirectedRequestAttrsKey( uri, hash );

                Map attrs = ( Map ) session.getAttribute( carryoverAttrName );

                session.removeAttribute( carryoverAttrName );

                if ( attrs != null )

                {

                    for ( Iterator i = attrs.entrySet().iterator(); i.hasNext(); )

                    {

                        Map.Entry entry = ( Map.Entry ) i.next();

                        String attrName = ( String ) entry.getKey();

                        if ( request.getAttribute( attrName ) == null )

                        {

                            request.setAttribute( attrName, entry.getValue() );

                        }

                    }

                }

            }

        }

        //

        // The requested action can be overridden by a request parameter.  In this case, we parse the action from

        // the request parameter and forward to a URI constructed from it.  If this happens, just return.

        //

        if ( processActionOverride( request, response ) ) return;

        //

        // Process any direct request for a page flow by forwarding to its "begin" action.

        //

        if ( processPageFlowRequest( request, response, uri ) ) return;

        //

        // Get the FlowController for this request (page flow or shared flow), and cache it in the request.

        //

        String flowControllerClassName = InternalUtils.getFlowControllerClassName( moduleConfig );

        if ( flowControllerClassName == null &&

             ! ( moduleConfig instanceof AutoRegisterActionServlet.MissingRootModuleControllerConfig ) )

        {

            //

            // If this isn't a blank module initialized in place of a missing root PageFlowController, emit a warning

            // about the missing controllerClass property.

            //

            _log.warn( "Struts module " + moduleConfig.getPrefix() + " is configured to use " + getClass().getName()

                        + " as the request processor, but the <controller> element does not contain a <set-property>"

                        + " for \"controllerClass\".  Page Flow actions in this module may not be handled correctly." );

        }

        //

        // Create the appropriate SharedFlowController if it doesn't exist.

        //

        if ( _log.isInfoEnabled() )

        {

            _log.info( "Attempting to instantiate SharedFlowControllers for request " + request.getRequestURI() );

        }

        FlowController currentFlowController = null;

        try

        {

            RequestContext requestContext = new RequestContext( request, response );

            Map/*< String, SharedFlowController >*/ sharedFlows =

                    _flowControllerFactory.getSharedFlowsForRequest( requestContext );

            ImplicitObjectUtil.loadSharedFlow( request, sharedFlows );

            ImplicitObjectUtil.loadGlobalApp( request, PageFlowUtils.getGlobalApp( request ) );

            if ( flowControllerClassName != null )

            {

                currentFlowController = getFlowController( requestContext, flowControllerClassName );

                PageFlowRequestWrapper.get( request ).setCurrentFlowController( currentFlowController );

            }

            else

            {

                PageFlowRequestWrapper.get( request ).setCurrentFlowController( null );

            }

        }

        catch ( ClassNotFoundException e )

        {

            _log.error( "Could not find FlowController class " + flowControllerClassName, e );

            throw new ServletException( e );

        }

        catch ( InstantiationException e )

        {

            _log.error( "Could not instantiate FlowController of type " + flowControllerClassName, e );

            throw new ServletException( e );

        }

        catch ( IllegalAccessException e )

        {

            _log.error( "Could not instantiate FlowController of type " + flowControllerClassName, e );

            throw new ServletException( e );

        }

        //

        // Get the page flow for this request.

        //

        PageFlowController jpf = PageFlowUtils.getCurrentPageFlow( request, getServletContext() );

        //

        // Remove any current JavaServer Faces backing bean.  We have "left" any JSF page and are now processing a

        // Page Flow action.

        //

        InternalUtils.removeCurrentFacesBackingBean( request, servletContext );

        //

        // Set up implicit objects used by the expression language in simple actions and in declarative validation.

        //

        ImplicitObjectUtil.loadImplicitObjects( request, response, servletContext, jpf );

        try

        {

            super.process( request, response );

        }

        catch ( UnhandledException unhandledException )

        {

            // If we get here, then we've already tried to find an exception handler.  Just throw.

            rethrowUnhandledException( unhandledException );

        }

        catch ( ServletException servletEx )

        {

            // If a ServletException escapes out of any of the processing methods, let the current FlowController handle it.

            if ( ! handleException( servletEx, currentFlowController, request, response ) ) throw servletEx;

        }

        catch ( IOException ioe )

        {

            // If an IOException escapes out of any of the processing methods, let the current FlowController handle it.

            if ( ! handleException( ioe, currentFlowController, request, response ) ) throw ioe;

        }

        catch ( Throwable th )

        {

            // If a Throwable escapes out of any of the processing methods, let the current FlowController handle it.

            if ( ! handleException( th, currentFlowController, request, response ) )

            {

                if ( th instanceof Error ) throw ( Error ) th;

                throw new ServletException( th );

            }

        }

    }

    private FlowController getFlowController( RequestContext requestContext, String fcClassName )

        throws ClassNotFoundException, InstantiationException, IllegalAccessException

    {

        Class fcClass = _flowControllerFactory.getFlowControllerClass( fcClassName );

        HttpServletRequest request = requestContext.getHttpRequest();

        HttpServletResponse response = requestContext.getHttpResponse();

        if ( PageFlowController.class.isAssignableFrom( fcClass ) )

        {

            PageFlowController current = PageFlowUtils.getCurrentPageFlow( request, getServletContext() );

            if ( current != null && current.getClass().equals( fcClass ) )

            {

                if ( _log.isDebugEnabled() )

                {

                    _log.debug( "Using current page flow: " + current );

                }

                //

                // Reinitialize transient data that may have been lost on session failover.

                //

                current.reinitialize( request, response, getServletContext() );

                return current;

            }

            return _flowControllerFactory.createPageFlow( new RequestContext( request, response ), fcClass );

        }

        else

        {

            assert SharedFlowController.class.isAssignableFrom( fcClass ) : fcClass.getName();

            SharedFlowController current = PageFlowUtils.getSharedFlow( fcClass.getName(), request );

            if ( current != null )

            {

                current.reinitialize( request, response, getServletContext() );

                return current;

            }

            return _flowControllerFactory.createSharedFlow( new RequestContext( request, response ), fcClass );

        }

    }

    private boolean handleException( Throwable th, FlowController fc, HttpServletRequest request,

                                     HttpServletResponse response )

    {

        if ( fc != null )

        {

            try

            {

                ActionMapping mapping = InternalUtils.getCurrentActionMapping( request );

                ActionForm form = InternalUtils.getCurrentActionForm( request );

                ActionForward fwd = fc.handleException( th, mapping, form, request, response );

                processForwardConfig( request, response, fwd );

                return true;

            }

            catch ( UnhandledException unhandledException )

            {

                if ( _log.isInfoEnabled() )

                {

                    _log.info( "This exception was unhandled by any exception handler.", unhandledException );

                }

                return false;

            }

            catch ( Throwable t )

            {

                _log.error( "Exception while handling exception " + th.getClass().getName()

                            + ".  The original exception will be thrown.", t );

                return false;

            }

        }

        return false;

    }

    /**

     * Process any direct request for a page flow by forwarding to its "begin" action.

     *

     * @param request the current HttpServletRequest

     * @param response the current HttpServletResponse

     * @param uri the decoded request URI

     * @return <code>true</code> if the request was for a page flow, in which case it was forwarded.

     * @throws IOException

     * @throws ServletException

     */

    protected boolean processPageFlowRequest( HttpServletRequest request, HttpServletResponse response, String uri )

        throws IOException, ServletException

    {

        //

        // Forward requests for *.jpf to the "begin" action within the appropriate Struts module.

        //

        if ( FileUtils.osSensitiveEndsWith( uri, PageFlowConstants.PAGEFLOW_EXTENSION ) )

        {

            //

            // Make sure the current module config matches the request URI.  If not, this could be an

            // EAR where the struts-config.xml wasn't included because of a compilation error.

            //

            String modulePath = PageFlowUtils.getModulePath( request );

            if ( ! moduleConfig.getPrefix().equals( modulePath ) )

            {

                if ( _log.isErrorEnabled() )

                {

                    InternalStringBuilder msg = new InternalStringBuilder( "No module configuration registered for " );

                    msg.append( uri ).append( " (module path " ).append( modulePath ).append( ")." );

                    _log.error( msg.toString() );

                }

                if ( modulePath.length() == 0 ) modulePath = "/";

                InternalUtils.sendDevTimeError( "PageFlow_NoModuleConf", null,

                                                HttpServletResponse.SC_INTERNAL_SERVER_ERROR, request, response,

                                                getServletContext(), new Object[]{ uri, modulePath } );

                return true;

            }

            //

            // Make sure that the requested pageflow matches the pageflow for the directory.

            //

            ActionMapping beginMapping = getBeginMapping();

            if ( beginMapping != null )

            {

                String desiredType = beginMapping.getParameter();

                desiredType = desiredType.substring( desiredType.lastIndexOf( '.' ) + 1 ) + JPF_EXTENSION;

                String requestedType = InternalUtils.getDecodedServletPath( request );

                requestedType = requestedType.substring( requestedType.lastIndexOf( '/' ) + 1 );

                if ( ! requestedType.equals( desiredType ) )

                {

                    if ( _log.isDebugEnabled() )

                    {

                        _log.debug( "Wrong .jpf requested for this directory: got " + requestedType

                                   + ", expected " + desiredType );

                    }

                    if ( _log.isErrorEnabled() )

                    {

                        InternalStringBuilder msg = new InternalStringBuilder( "Wrong .jpf requested for this directory: got " );

                        msg.append( requestedType ).append( ", expected " ).append( desiredType ).append( '.' );

                        _log.error( msg.toString() );

                    }

                    InternalUtils.sendDevTimeError( "PageFlow_WrongPath", null,

                                                    HttpServletResponse.SC_INTERNAL_SERVER_ERROR, request, response,

                                                    getServletContext(), new Object[]{ requestedType, desiredType } );

                    return true;

                }

            }

            uri = PageFlowUtils.getBeginActionURI( uri );

            if ( _log.isDebugEnabled() )

            {

                _log.debug( "Got request for " + request.getRequestURI() + ", forwarding to " + uri );

            }

            doForward( uri, request, response );

            return true;

        }

        return false;

    }

    /**

     * A MultipartRequestWrapper that we cache in the outer request once we've handled the multipart request once.

     * It extends the base Struts MultipartRequestWrapper by being aware of ScopedRequests; for ScopedRequests, it

     * filters the parameter names accordingly.

     */

    private static class RehydratedMultipartRequestWrapper extends MultipartRequestWrapper

    {

        public RehydratedMultipartRequestWrapper( HttpServletRequest req )

        {

            super( req );

            MultipartRequestHandler handler = MultipartRequestUtils.getCachedMultipartHandler( req );

            if ( handler != null )

            {

                ScopedRequest scopedRequest = ScopedServletUtils.unwrapRequest( req );

                Map textElements = handler.getTextElements();

                parameters = scopedRequest != null ? scopedRequest.filterParameterMap( textElements ) : textElements;

            }

        }

    }

    public void process( HttpServletRequest request, HttpServletResponse response )

        throws IOException, ServletException

    {

        int localRequestCount = -1;

        if ( _log.isTraceEnabled() )

        {

            localRequestCount = ++requestNumber;

            _log.trace( "------------------------------- Start Request #" + localRequestCount

                       + " -----------------------------------" );

        }

        //

        // First reinitialize the reloadable class handler.  This will bounce a classloader if necessary.

        //

        ServletContext servletContext = getServletContext();

        _handlers.getReloadableClassHandler().reloadClasses( new RequestContext( request, response ) );

        //

        // Go through the chain of pre-request interceptors.

        //

        RequestInterceptorContext context = new RequestInterceptorContext( request, response, getServletContext() );

        List/*< Interceptor >*/ interceptors = context.getRequestInterceptors();

        try

        {

            Interceptors.doPreIntercept( context, interceptors );

            if ( context.requestWasCancelled() )

            {

                if ( _log.isDebugEnabled() )

                {

                    _log.debug ( "Interceptor " + context.getOverridingInterceptor() + " cancelled the request." );

                }

                return;

            }

        }

        catch ( InterceptorException e )

        {

            throw new ServletException( e );

        }

        //

        // Initialize the ServletContext in the request.  Often, we need access to the ServletContext when we only

        // have a ServletRequest.

        //

        InternalUtils.setServletContext( request, servletContext );

        //

        // Callback to the server adapter.

        //

        PageFlowEventReporter er = _servletContainerAdapter.getEventReporter();

        _servletContainerAdapter.beginRequest( request, response );

        RequestContext requestContext = new RequestContext( request, response );

        er.beginActionRequest( requestContext );

        long startTime = System.currentTimeMillis();

        //

        // Initialize the ControlBeanContext in the session.

        //

        JavaControlUtils.initializeControlContext( request, response, servletContext );

        //

        // Register the default URLRewriter

        //

        URLRewriterService.registerURLRewriter( 0, request, new DefaultURLRewriter() );

        PageFlowRequestWrapper rw = PageFlowRequestWrapper.unwrap( request );

        boolean isForwardedRequest = rw != null && rw.isForwardedRequest();

        try

        {

            processInternal( request, response );

        }

        finally

        {

            //

            // If this is not a forwarded request, then commit any session-scoped changes that were stored in the

            // request.

            //

            if ( ! isForwardedRequest )

            {

                Handlers.get( getServletContext() ).getStorageHandler().applyChanges( requestContext );

            }

            //

            // Clean up the ControlBeanContext in the session.

            //

            JavaControlUtils.uninitializeControlContext( request, response, getServletContext() );

            //

            // Callback to the server adapter.

            //

            _servletContainerAdapter.endRequest( request, response );

            long timeTaken = System.currentTimeMillis() - startTime;

            er.endActionRequest( requestContext, timeTaken );

        }

        //

        // Go through the chain of pre-request interceptors.

        //

        try

        {

            Interceptors.doPostIntercept( context, interceptors );

        }

        catch ( InterceptorException e )

        {

            throw new ServletException( e );

        }

        if ( _log.isTraceEnabled() )

        {

            _log.trace( "-------------------------------- End Request #" + localRequestCount

                       + " ------------------------------------" );

        }

    }

    /**

     * If this is a multipart request, wrap it with a special wrapper.  Otherwise, return the request unchanged.

     *

     * @param request The HttpServletRequest we are processing

     */

    protected HttpServletRequest processMultipart( HttpServletRequest request )

    {

        if ( ! "POST".equalsIgnoreCase( request.getMethod() ) ) return request;

        String contentType = request.getContentType();

        if ( contentType != null && contentType.startsWith( "multipart/form-data" ) )

        {

            PageFlowRequestWrapper pageFlowRequestWrapper = PageFlowRequestWrapper.get( request );

            //

            // We may have already gotten a multipart wrapper during process().  If so, use that.

            //

            MultipartRequestWrapper cachedWrapper = pageFlowRequestWrapper.getMultipartRequestWrapper();

            if ( cachedWrapper != null && cachedWrapper.getRequest() == request ) return cachedWrapper;

            try

            {

                //

                // First, pre-handle the multipart request.  This parses the stream and caches a single

                // MultipartRequestHandler in the outer request, so we can create new wrappers around it at will.

                //

                MultipartRequestUtils.preHandleMultipartRequest( request );

            }

            catch ( ServletException e )

            {

                _log.error( "Could not parse multipart request.", e.getRootCause() );

                return request;

            }

            MultipartRequestWrapper ret = new RehydratedMultipartRequestWrapper( request );

            pageFlowRequestWrapper.setMultipartRequestWrapper( ret );

            return ret;

        }

        else

        {

            return request;

        }

    }

    protected ActionMapping getBeginMapping()

    {

        return ( ActionMapping ) moduleConfig.findActionConfig( BEGIN_ACTION_PATH );

    }

    private static String makeRedirectedRequestAttrsKey( String webappRelativeURI, String hash )

    {

        return REDIRECT_REQUEST_ATTRS_PREFIX + hash + webappRelativeURI;

    }

    private static final void rethrowUnhandledException( UnhandledException ex )

        throws ServletException

    {

        Throwable rootCause = ex.getRootCause();

        //

        // We shouldn't (and don't need to) wrap Errors or RuntimeExceptions.

        //

        if ( rootCause instanceof Error )

        {

            throw ( Error ) rootCause;

        }

        else if ( rootCause instanceof RuntimeException )

        {

            throw ( RuntimeException ) rootCause;

        }

        throw ex;

    }

    public ActionForward processException( HttpServletRequest request, HttpServletResponse response,

                                           Exception ex, ActionForm form, ActionMapping mapping )

        throws IOException, ServletException

    {

        //

        // Note: we should only get here if FlowController.handleException itself throws an exception, or if the user

        // has merged in Struts code that delegates to an action/exception-handler outside of the pageflow.

        //

        // If this is an UnhandledException thrown from FlowController.handleException, don't try to re-handle it here.

        //

        if ( ex instanceof UnhandledException )

        {

            rethrowUnhandledException( ( UnhandledException ) ex );

            assert false;   // rethrowUnhandledException always throws something.

            return null;

        }

        else

        {

            return super.processException( request, response, ex, form, mapping );

        }

    }

    /**

     * Used by {@link PageFlowRequestProcessor#processMapping}.  Its main job is to return

     * {@link ExceptionHandledAction} as the type.

     */

    protected static class ExceptionHandledActionMapping extends ActionMapping

    {

        private ActionForward _fwd;

        public ExceptionHandledActionMapping( String actionPath, ActionForward fwd )

        {

            setPath( actionPath );

            _fwd = fwd;

        }

        public String getType()

        {

            return ExceptionHandledAction.class.getName();

        }

        public ActionForward getActionForward()

        {

            return _fwd;

        }

        public boolean getValidate()

        {

            return false;

        }

    }

    /**

     * Used by {@link PageFlowRequestProcessor#processMapping}.  This action simply returns the ActionForward stored in the

     * ExceptionHandledActionMapping that's passed in.

     */

    public static class ExceptionHandledAction extends Action

    {

        public ActionForward execute( ActionMapping mapping, ActionForm form, HttpServletRequest request,

                                      HttpServletResponse response )

        {

            assert mapping instanceof ExceptionHandledActionMapping : mapping.getClass().getName();

            return ( ( ExceptionHandledActionMapping ) mapping ).getActionForward();

        }

    }

    private boolean isCorrectFormType( Class formBeanClass, ActionMapping mapping )

    {

        assert mapping.getName() != null : "cannot pass an ActionMapping that has no form bean";

        Class cachedFormBeanClass = ( Class ) _formBeanClasses.get( mapping.getName() );

        return isCorrectFormType( formBeanClass, cachedFormBeanClass, mapping );

    }

    private boolean isCorrectFormType( Class formBeanClass, Class actionMappingFormBeanClass, ActionMapping mapping )

    {

        if ( actionMappingFormBeanClass != null )

        {

            return actionMappingFormBeanClass .isAssignableFrom( formBeanClass );

        }

        else

        {

            //

            // The form bean class couldn't be loaded at init time -- just check against the class name.

            //

            FormBeanConfig mappingFormBean = moduleConfig.findFormBeanConfig( mapping.getName() );

            String formClassName = formBeanClass.getName();

            if ( mappingFormBean != null && mappingFormBean.getType().equals( formClassName ) ) return true;

            if ( mapping instanceof PageFlowActionMapping )

            {

                String desiredType = ( ( PageFlowActionMapping ) mapping ).getFormClass();

                if ( formClassName.equals( desiredType ) ) return true;

            }

        }

        return false;

    }