RequestMapper.java

/*
 *  This file is part of the Wayback archival access software
 *   (http://archive-access.sourceforge.net/projects/wayback/).
 *
 *  Licensed to the Internet Archive (IA) by one or more individual 
 *  contributors. 
 *
 *  The IA 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.archive.wayback.util.webapp;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.logging.Logger;

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

import org.archive.wayback.core.UIResults;

/**
 * This class maintains a mapping of RequestHandlers and ShutDownListeners, to
 * allow (somewhat) efficient mapping and delegation of incoming requests to
 * the appropriate RequestHandler.
 * 
 * This class uses PortMapper to delegate some of the responsibility of mapping
 * requests received on a particular port, and also allows configuration of a
 * global PRE RequestHandler, which gets first dibs on EVERY incoming request,
 * as well as a global POST RequestHandler, which may attempt to handle any
 * incoming request not handled by the normal RequestHandler mapping.
 * 
 * @author brad
 *
 */
public class RequestMapper {

	private static final Logger LOGGER = Logger.getLogger(
			RequestMapper.class.getName());
	
	private ArrayList<ShutdownListener> shutdownListeners = null;
	
	private HashMap<Integer,PortMapper> portMap = null;
	private RequestHandler globalPreRequestHandler = null;
	private RequestHandler globalPostRequestHandler = null;
	
	/**
	 * The name of an attribute for storing the prefix of URL
	 * path corresponding to the {@link RequestHandler} processing
	 * the request.
	 */
	public static final String REQUEST_CONTEXT_PREFIX =
		"webapp-request-context-path-prefix";
	
	/**
	 * Bean name used to register the special global PRE RequestHandler. 
	 */
	public final static String GLOBAL_PRE_REQUEST_HANDLER = "-";
	/**
	 * Bean name used to register the special global POST RequestHandler. 
	 */
	public final static String GLOBAL_POST_REQUEST_HANDLER = "+";

	/**
	 * Construct a RequestMapper, for the given RequestHandler objects, on the
	 * specified ServletContext. This method will call setServletContext() on
	 * each RequestMapper, followed immediately by registerPortListener()
	 * 
	 * @param requestHandlers Collection of RequestHandlers which handle 
	 * requests
	 * @param servletContext the webapp ServletContext where this RequestMapper
	 * is configured.
	 */
	public RequestMapper(Collection<RequestHandler> requestHandlers,
			ServletContext servletContext) {
		portMap = new HashMap<Integer, PortMapper>();
		shutdownListeners = new ArrayList<ShutdownListener>();
		Iterator<RequestHandler> itr = requestHandlers.iterator();
		LOGGER.info("Registering handlers.");
		while(itr.hasNext()) {
			RequestHandler requestHandler = itr.next();
			requestHandler.setServletContext(servletContext);
			requestHandler.registerPortListener(this);
		}
		LOGGER.info("Registering handlers complete.");
	}

	/**
	 * Request the shutdownListener object to be notified of ServletContext
	 * shutdown.
	 * @param shutdownListener the object which needs to have shutdown() called
	 * when the ServletContext is destroyed.
	 */
	public void addShutdownListener(ShutdownListener shutdownListener) {
		shutdownListeners.add(shutdownListener);
	}
	/**
	 * Configure the specified RequestHandler to handle ALL incoming requests
	 * before any other normal mapping.
	 * @param requestHandler the global PRE RequestHandler
	 */
	public void addGlobalPreRequestHandler(RequestHandler requestHandler) {
		globalPreRequestHandler = requestHandler;
	}
	/**
	 * Configure the specified RequestHandler to handle ALL incoming requests
	 * after all other normal mapping has been attempted
	 * @param requestHandler the global POST RequestHandler
	 */
	public void addGlobalPostRequestHandler(RequestHandler requestHandler) {
		globalPostRequestHandler = requestHandler;
	}
	/**
	 * Register the RequestHandler to accept requests on the given port, for the
	 * specified host and path.
	 * @param port the integer port on which the RequestHandler gets requests.
	 * @param host the String Host which the RequestHandler matches, or null, if
	 * the RequestHandler should match ALL hosts.
	 * @param path the String path which the RequestHandler matches, or null, if
	 * the RequestHandler should match ALL paths.
	 * @param requestHandler the RequestHandler to register.
	 */
	public void addRequestHandler(int port, String host, String path, 
			RequestHandler requestHandler) {
		Integer portInt = Integer.valueOf(port);
		PortMapper portMapper = portMap.get(portInt);
		if (portMapper == null) {
			portMapper = new PortMapper(portInt);
			portMap.put(portInt, portMapper);
		}
		portMapper.addRequestHandler(host, path, requestHandler);
		LOGGER.info("Registered " + port + "/" +
				(host == null ? "*" : host) + "/" +
				(path == null ? "*" : path) + " --> " +
				requestHandler);
	}

	public RequestHandlerContext mapRequest(HttpServletRequest request) {
		RequestHandlerContext handlerContext = null;
		
		int port = request.getLocalPort();
		Integer portInt = Integer.valueOf(port);
		PortMapper portMapper = portMap.get(portInt);
		if (portMapper != null) {
			handlerContext = portMapper.getRequestHandlerContext(request);
		} else {
			LOGGER.warning("No PortMapper for port " + port);
		}
		return handlerContext;
	}
	
	/**
	 * Map the incoming request to the appropriate RequestHandler, including
	 * the PRE and POST RequestHandlers, if configured.
	 * @param request the incoming HttpServletRequest
	 * @param response the HttpServletResponse to return data to the client
	 * @return true if a response was returned to the client.
	 * @throws ServletException for usual reasons.
	 * @throws IOException for usual reasons.
	 */
	public boolean handleRequest(HttpServletRequest request,
			HttpServletResponse response) throws IOException, ServletException {
		boolean handled = false;
		
		// Internally UIResults.forward(), don't handle here
		if (request.getAttribute(UIResults.FERRET_NAME) != null) {
			return false;
		}
		
		if (globalPreRequestHandler != null) {
			handled = globalPreRequestHandler.handleRequest(request, response);
		}
		if (handled == false) {
			RequestHandlerContext handlerContext = mapRequest(request);
			if (handlerContext != null) {
				RequestHandler requestHandler = 
					handlerContext.getRequestHandler();
				// need to add trailing "/" iff prefix is not "/":
				String pathPrefix = handlerContext.getPathPrefix();
				if (!pathPrefix.equals("/")) {
					pathPrefix += "/";
				}
				request.setAttribute(REQUEST_CONTEXT_PREFIX,pathPrefix); 
				handled = requestHandler.handleRequest(request, response);
			}
		}
		if (handled == false) {
			if(globalPostRequestHandler != null) {
				handled = globalPostRequestHandler.handleRequest(request,
						response);
			}
		}
			
		return handled;
	}

	/**
	 * notify all registered ShutdownListener objects that the ServletContext is
	 * being destroyed.
	 */
	public void shutdown() {
		for (ShutdownListener shutdownListener : shutdownListeners) {
			try {
				shutdownListener.shutdown();
			} catch(Exception e) {
				LOGGER.severe("failed shutdown"+e.getMessage());
			}
		}
	}
	
	/**
	 * Extract the request path prefix, as computed at RequestHandler mapping,
	 * from the HttpServletRequest object.
	 * 
	 * @param request HttpServlet request object being handled
	 * @return the portion of the original request path which indicated the 
	 * RequestHandler, including the trailing '/'.
	 */
	public static String getRequestPathPrefix(HttpServletRequest request) {
		return (String) request.getAttribute(REQUEST_CONTEXT_PREFIX);
	}

	/**
	 * @param request HttpServlet request object being handled
	 * @return the portion of the incoming path within the RequestHandler
	 * handling the request, not including a leading "/", and not including 
	 * query arguments.
	 */
	public static String getRequestContextPath(HttpServletRequest request) {
		String prefix = (String) request.getAttribute(REQUEST_CONTEXT_PREFIX);
		String requestUrl = request.getRequestURI();
		if (prefix == null) {
			return requestUrl;
		}
		if (requestUrl.startsWith(prefix)) {
			return requestUrl.substring(prefix.length());
		}
		return requestUrl;
	}

	/**
	 * @param request HttpServlet request object being handled
	 * @return the portion of the incoming path within the RequestHandler
	 * handling the request, not including a leading "/", including query 
	 * arguments.
	 */
	public static String getRequestContextPathQuery(HttpServletRequest request) {
		String prefix = (String)request.getAttribute(REQUEST_CONTEXT_PREFIX);
		// HttpServletRequest.getRequestURI() returns path portion of request URL
		// (does not include query part), *undecoded*.
		StringBuilder sb = new StringBuilder(request.getRequestURI());
		String requestUrl = null;
		String query = request.getQueryString();
		if (query != null) {
			requestUrl = sb.append("?").append(query).toString();
		} else {
			requestUrl = sb.toString();
		}
		if (prefix == null) {
			return requestUrl;
		}
		if (requestUrl.startsWith(prefix)) {
			return requestUrl.substring(prefix.length());
		} 
		// Fix for access point with missing end slash
		else if (prefix.endsWith("/") && (requestUrl + "/").equals(prefix)) {
			return "";
		}
		return requestUrl;
	}
}