2009/05/20 - Apache Shale has been retired.

 /*

  * Licensed to the Apache Software Foundation (ASF) under one or more

  * contributor license agreements.  See the NOTICE file distributed with

  * this work for additional information regarding copyright ownership.

  * The ASF licenses this file to you 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.

  */

 package org.apache.shale.remoting.impl;

 import java.io.IOException;

 import javax.faces.context.FacesContext;

 import javax.faces.el.MethodBinding;

 import javax.servlet.ServletContext;

 import javax.servlet.http.HttpServletResponse;

 import org.apache.commons.logging.Log;

 import org.apache.commons.logging.LogFactory;

 import org.apache.shale.remoting.Constants;

 import org.apache.shale.remoting.impl.FilteringProcessor;

 import org.apache.shale.remoting.Processor;

 /**

  * <p>Implementation of {@link Processor} which maps a resource identifier

  * to a method binding expression, then delegates the creation of the current

  * response to the execution of that method.  The precise details of how a

  * resource identifier gets mapped are encapsulated in the <code>mapResourceId</code>

  * method, which may be specialized as desired in a subclass.</p>

  */

 public class MethodBindingProcessor extends FilteringProcessor {

     // ------------------------------------------------------------ Constructors

     // ------------------------------------------------------ Instance Variables

     /**

      * <p><code>Log</code> instance for this class.</p>

      */

     private transient Log log = null;

     // -------------------------------------------------------------- Properties

     /**

      * <p>Force our default excludes list to be included.</p>

      *

      * @param excludes Application specified excludes list

      */

     public void setExcludes(String excludes) {

         if ((excludes != null) && (excludes.length() > 0)) {

             super.setExcludes(Constants.DYNAMIC_RESOURCES_EXCLUDES_DEFAULT

                               + "," + excludes);

         } else {

             super.setExcludes(Constants.DYNAMIC_RESOURCES_EXCLUDES_DEFAULT);

         }

     }

     // ------------------------------------------------------- Processor Methods

     /**

      * <p>Convert the specified resource identifier into a method binding

      * expression, and delegate creation of the response to a call to the

      * identified method.  Call <code>FacesContext.responseComplete()</code>

      * to tell JavaServer Faces that the entire response has already been

      * created.</p>

      *

      * @param context <code>FacesContext</code> for the current request

      * @param resourceId Resource identifier used to select the appropriate response

      *  (this will generally be a context relative path starting with "/")

      *

      * @exception IllegalArgumentException if the view identifier is not

      *  well formed (starting with a '/' character)

      * @exception IOException if an input/output error occurs

      * @exception NullPointerException if <code>viewId</code> is <code>null</code>

      */

     public void process(FacesContext context, String resourceId) throws IOException {

         // If someone else has completed the response, we do not have

         // anything to do

         if (context.getResponseComplete()) {

             return;

         }

         // Filter based on our includes and excludes patterns

         if (!accept(resourceId)) {

             if (log().isTraceEnabled()) {

                 log().trace("Resource id '" + resourceId

                             + "' rejected by include/exclude rules");

             }

             // Send an HTTP "not found" response to avoid giving the client

             // any information about a resource that exists and was refused,

             // versus a resource that does not exist

             sendNotFound(context, resourceId);

             context.responseComplete();

             return;

         }

         // Create and execute a method binding based on this resource identifier

         MethodBinding mb = mapResourceId(context, resourceId);

         if (log().isDebugEnabled()) {

             log().debug("Translated resource id '" + resourceId

                         + "' to method binding expression '"

                         + mb.getExpressionString() + "'");

         }

         mb.invoke(context, new Object[] { });

         // Tell JavaServer Faces that the current response has been completed

         context.responseComplete();

     }

     // ------------------------------------------------------- Protected Methods

     /**

      * <p>Map the specified resource identifier into a corresponding

      * <code>MethodBinding</code> which identifies the method which will be

      * called to produce this response.</p>

      *

      * <p>The default algorithm performs this conversion as follows:</p>

      * <ul>

      * <li>Strip any leading slash character.</li>

      * <li>Convert embedded slash characters to periods.</li>

      * <li>Surround the result with "#{" and "}" delimiters.</li>

      * <li>Ask JavaServer Faces to create a method binding, using this

      *     expression, for a method that takes no parameters.</li>

      * </ul>

      *

      * @param context <code>FacesContext</code> for the current request

      * @param resourceId Resource identifier to be mapped

      */

     protected MethodBinding mapResourceId(FacesContext context, String resourceId) {

         // Strip any leading slash character

         if (resourceId.startsWith("/")) {

             resourceId = resourceId.substring(1);

         }

         // Convert nested slash characters into periods

         // FIXME - this will have problematic results on managed bean names that have periods

         resourceId = resourceId.replace('/', '.');

         // Surround the result with "#{" and "}" delimiters

         resourceId = "#{" + resourceId + "}";

         // Return a MethodBinding expression based on this mapping

         return context.getApplication().createMethodBinding(resourceId,

                 new Class[] { });

     }

     // --------------------------------------------------------- Private Methods

     /**

      * <p>Return the <code>Log</code> instance to use, creating one if needed.</p>

      */

     private Log log() {

         if (this.log == null) {

             log = LogFactory.getLog(MethodBindingProcessor.class);

         }

         return log;

     }

     /**

      * <p>Send a "not found" HTTP response, if possible.  Otherwise, throw an

      * <code>IllegalArgumentException</code> that will ripple out.</p>

      *

      * @param context <code>FacesContext</code> for the current request

      * @param resourceId Resource identifier of the resource that was not found

      *

      * @exception IllegalArgumentException if we cannot send an HTTP response

      * @exception IOException if an input/output error occurs

      *

      * @since 1.0.4

      */

     private void sendNotFound(FacesContext context, String resourceId) throws IOException {

         if (servletRequest(context)) {

             HttpServletResponse response = (HttpServletResponse)

               context.getExternalContext().getResponse();

             response.sendError(HttpServletResponse.SC_NOT_FOUND, resourceId);

         } else {

             throw new IllegalArgumentException(resourceId);

         }

     }

     /**

      * <p>Return <code>true</code> if we are processing a servlet request (as

      * opposed to a portlet request).</p>

      *

      * @param context <code>FacesContext</code> for the current request

      *

      * @since 1.0.4

      */

     private boolean servletRequest(FacesContext context) {

         return context.getExternalContext().getContext() instanceof ServletContext;

     }

 }