PortMapper.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.util.ArrayList;
import java.util.HashMap;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.servlet.http.HttpServletRequest;

/**
 * 
 * Class which allows semi-efficient translation of requests on a specific local
 * port to a RequestHandler object.
 * 
 * Mapping within a port is based on the HTTP 1.1 Host field and the first
 * segment of the requested PATH, that is, whatever is after the context where
 * the wayback webapp was deployed, and before the first '/'.
 * 
 * @author brad
 */
public class PortMapper {
	private static final Logger LOGGER = Logger.getLogger(
			PortMapper.class.getName());
	private int port = -1;
	private HashMap<String, RequestHandler> pathMap = null;
	/**
	 * @param port which this PortMapper is responsible for handling
	 */
	public PortMapper(int port) {
		this.port = port;
		pathMap = new HashMap<String, RequestHandler>();
	}
	private String hostPathToKey(String host, String firstPath) {
		StringBuilder sb = null;
		if((host == null) && (firstPath == null)) {
			return null;
		}
		sb = new StringBuilder();
		if(host != null) {
			sb.append(host);
		}
		sb.append("/");
		if(firstPath != null) {
			sb.append(firstPath);
		}
		return sb.toString();
	}
	/**
	 * Register the RequestHandler to accept requests for the given host and 
	 * port.
	 * @param host the HTTP 1.1 "Host" header which the RequestHandler should 
	 * match. If null, the RequestHandler matches any "Host" header value.
	 * @param firstPath the first path of the GET request path which the
	 * RequestHandler should match. This is the first path AFTER the name the 
	 * Wayback webapp is deployed under. If null, the RequestHandler matches
	 * all paths.
	 * @param requestHandler The RequestHandler to register.
	 */
	public void addRequestHandler(String host, String firstPath, 
			RequestHandler requestHandler) {
		String key = hostPathToKey(host, firstPath);
		if (pathMap.containsKey(key)) {
			LOGGER.warning("Duplicate port:path map for " + port +
					":" + key);
		} else {
			pathMap.put(key, requestHandler);
			if (LOGGER.isLoggable(Level.FINE)) {
				LOGGER.fine("Registered requestHandler(port/host/path) (" +
						port + "/" + host + "/" + firstPath + "): " + key);
			}
		}
	}
	
	private String requestToFirstPath(HttpServletRequest request) {
		String firstPath = null;
		String requestPath = request.getRequestURI();
		String contextPath = request.getContextPath();
		if((contextPath.length() > 0) && requestPath.startsWith(contextPath)) {
			requestPath = requestPath.substring(contextPath.length());
		}
		while(requestPath.startsWith("/")) {
			requestPath = requestPath.substring(1);
		}
		
		int slashIdx = requestPath.indexOf("/",1);
		if(slashIdx == -1) {
			firstPath = requestPath;
		} else {
			firstPath = requestPath.substring(0,slashIdx);
		}
		return firstPath;
	}

	private String requestToHost(HttpServletRequest request) {
		return request.getServerName();
	}	
	
	/**
	 * Attempts to locate the most strictly matching RequestHandler mapped to
	 * this port. Strictly matching means the lowest number in the following 
	 * list:
	 * 
	 * 1) request handler matching both HOST and PATH
	 * 2) request handler matching host, registered with an empty PATH
	 * 3) request handler matching path, registered with an empty HOST
	 * 4) request handler registered with empty HOST and PATH
	 * 
	 * @param request the HttpServletRequest to be mapped to a RequestHandler
	 * @return the RequestHandlerContext, containing the RequestHandler and the
	 * prefix of the original request path that indicated the RequestHandler,
	 * or null, if no RequestHandler matches.
	 */
	public RequestHandlerContext getRequestHandlerContext(
			HttpServletRequest request) {
		String host = requestToHost(request);
		String contextPath = request.getContextPath();
		StringBuilder pathPrefix = new StringBuilder(contextPath);
//		if(contextPath.length() == 0) {
			pathPrefix.append("/");
//		}
		String firstPath = requestToFirstPath(request);
		String key = hostPathToKey(host,firstPath);
		RequestHandler handler = pathMap.get(key);
		if(handler != null) {
			LOGGER.fine("Mapped to RequestHandler with " + key);
			return new RequestHandlerContext(handler,
					pathPrefix.append(firstPath).toString());
		} else {
			LOGGER.finer("No mapping for " + key);			
		}
		key = hostPathToKey(host,null);
		handler = pathMap.get(key);
		if(handler != null) {
			LOGGER.fine("Mapped to RequestHandler with " + key);
			return new RequestHandlerContext(handler,contextPath);
		} else {
			LOGGER.finer("No mapping for " + key);			
		}
		key = hostPathToKey(null,firstPath);
		handler = pathMap.get(key);
		if(handler != null) {
			LOGGER.fine("Mapped to RequestHandler with " + key);

			return new RequestHandlerContext(handler,
					pathPrefix.append(firstPath).toString());
		} else {
			LOGGER.finer("No mapping for " + key);			
		}
		handler = pathMap.get(null);
		if(handler != null) {
			LOGGER.fine("Mapped to RequestHandler with null");
			return new RequestHandlerContext(handler,contextPath);
		}
		// Nothing matching this port:host:path. Try to help get user back on
		// track. Note this won't help with hostname mismatches at the moment:
		ArrayList<String> paths = new ArrayList<String>();
		for(String tmp : pathMap.keySet()) {
			// slice off last chunk:
			int idx = tmp.lastIndexOf('/');
			if(idx != -1) {
				String path = tmp.substring(idx+1);
				paths.add(path);
			}
		}
		if(paths.size() > 0) {
			request.setAttribute("AccessPointNames", paths);
		}
		return null;
	}
}