StaticsLegacyDispatcher.java

/**
* OLAT - Online Learning and Training<br>
* http://www.olat.org
* <p>
* Licensed under the Apache License, Version 2.0 (the "License"); <br>
* you may not use this file except in compliance with the License.<br>
* You may obtain a copy of the License at
* <p>
* http://www.apache.org/licenses/LICENSE-2.0
* <p>
* Unless required by applicable law or agreed to in writing,<br>
* software distributed under the License is distributed on an "AS IS" BASIS, <br>
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
* See the License for the specific language governing permissions and <br>
* limitations under the License.
* <p>
* Copyright (c) since 2004 at Multimedia- & E-Learning Services (MELS),<br>
* University of Zurich, Switzerland.
* <hr>
* <a href="http://www.openolat.org">
* OpenOLAT - Online Learning and Training</a><br>
* This file has been modified by the OpenOLAT community. Changes are licensed
* under the Apache 2.0 license as the original file.
*/
package org.olat.commons.servlets;

import java.io.IOException;
import java.io.InputStream;

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

import org.apache.commons.io.IOUtils;
import org.olat.commons.servlets.pathhandlers.PathHandler;
import org.olat.commons.servlets.util.ResourceDescriptor;
import org.olat.core.dispatcher.Dispatcher;
import org.olat.core.dispatcher.DispatcherModule;
import org.olat.core.gui.media.MediaResource;
import org.olat.core.gui.media.ServletUtil;
import org.olat.core.logging.OLog;
import org.olat.core.logging.Tracing;

/**
 * @author Mike Stock Comment:
 *         <p>
 *         This class use to be the StaticsServlet.class. It has been refactored
 *         to implement the dispatcher interface. Please note that this statics
 *         dispatcher is legacy and should not be used to deliver static
 *         resources anymore. See the deprecated comments for more information.
 *         <p>
 *         This servlet extracts a handlerName from the first sub-path of the
 *         request's relative path. StaticsModule provides a handler class based
 *         on that name. Handler classes are configured in jpublish-xml's config
 *         for the StaticsModule. Handlers must implement the PathHandler
 *         interface. See FilePathHandler for an example of a PathHandler which
 *         resolves files in a filesystem. A handler is called by this servlet
 *         with the remaining path as argument. The handlers know how to get to
 *         the resource themselves.
 *         <p>
 * @deprecated Please use GlobalMapperRegistry if you need to provide an url for
 *             e.g. static resources which are shared by all users
 */
public class StaticsLegacyDispatcher implements Dispatcher {
	private static final OLog log = Tracing.createLoggerFor(StaticsLegacyDispatcher.class);

    /**
     * Default constructor.
     */
    public StaticsLegacyDispatcher() {
        super();
    }
		
	/**
     * @see org.olat.core.dispatcher.Dispatcher#execute(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, java.lang.String)
     */
	@Override
	public void execute(HttpServletRequest req, HttpServletResponse resp) {
		try {
    		String method = req.getMethod();
	        if (method.equals("GET")) {
	            doGet(req, resp);
	        } else if (method.equals("HEAD")) {
	            doHead(req, resp);
	        } else {
	        	DispatcherModule.sendNotFound(req.getRequestURI(), resp);
	        }
		} catch (IOException e) {
			/*
			 * silently ignore forward errors (except in debug mode), since IE
			 * causes tons of such messages by its double GET request
			 */
			if (log.isDebug()) {
				log.debug("could not execute legacy statics method:" + e.toString() + ",msg:" + e.getMessage());
			}
		}
    }

    /**
     * Process a GET request for the specified resource.
     * 
     * @param request
     *            The servlet request we are processing
     * @param response
     *            The servlet response we are creating
     * 
     * @exception IOException
     *                if an input/output error occurs
     */
    protected void doGet(HttpServletRequest request,  HttpServletResponse response) throws IOException {
        // just to indicate that method must return if false is returned
        if (!serveResource(request, response, true)) {
        	return;
        }
    }

    /**
     * Process a HEAD request for the specified resource.
     * 
     * @param request
     *            The servlet request we are processing
     * @param response
     *            The servlet response we are creating
     * 
     * @exception IOException
     *                if an input/output error occurs
     */
    protected void doHead(HttpServletRequest request, HttpServletResponse response) throws IOException {
        // just to indicate that method must return if false is returned
        if (!serveResource(request, response, false)) {
        	return;
        }
    }

    /**
     * Serve the requested resource.
     * 
     * @param request
     * @param response
     * @param copyContent
     * @return False if serving the resource failed/was aborted.
     * @throws IOException
     */
    private boolean serveResource(HttpServletRequest request, HttpServletResponse response, boolean copyContent)
            throws IOException {
        // just another internal forward or even a direct call
        String path = getRelativePath(request);
        if (path.indexOf("/secstatic/") == 0) {
        	path = path.substring(10, path.length());
        }
        PathHandler handler = null;
        String relPath = null;
        String handlerName = null;
        long start = 0;
        
        boolean logDebug = log.isDebug();
        if (logDebug) start = System.currentTimeMillis();
        try {
            relPath = path.substring(1);
            int index = relPath.indexOf('/');
            if (index != -1) {
                handlerName = relPath.substring(0, index);
                relPath = relPath.substring(index);
            }

            if (handlerName != null) {
                    handler = StaticsModule.getInstance(handlerName);
            }
        } catch (IndexOutOfBoundsException e) {
            // if some problem with the url, we assign no handler
        }

        if (handler == null || relPath == null) {
            // no handler found or relPath incomplete
            response.sendError(HttpServletResponse.SC_NOT_FOUND, request.getRequestURI());
            return false;
        }

        ResourceDescriptor rd = handler.getResourceDescriptor(request, relPath);
        if (rd == null) {
            // no handler found or relPath incomplete
            response.sendError(HttpServletResponse.SC_NOT_FOUND, request.getRequestURI());
            return false;
        }

        // check if modified since
        long ifModifiedSince = request.getDateHeader("If-Modified-Since");
        long lastMod = rd.getLastModified();
        if (lastMod != -1L && ifModifiedSince >= lastMod) {
            response.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
            return false;
        }

        // server the resource
        if (copyContent) {
            InputStream is = handler.getInputStream(request, rd);
            if (is == null) {
                // resource not found or access denied
                response.sendError(HttpServletResponse.SC_NOT_FOUND, request.getRequestURI());
                return false;
            }
            StaticMediaResource smr = new StaticMediaResource(is, rd);
            ServletUtil.serveResource(request, response, smr);
            if (logDebug) {
                long stop = System.currentTimeMillis();  
                log.debug("Serving resource '" + relPath + "' ("+rd.getSize()+" bytes) in "+ (stop-start) +"ms with handler '" + handlerName + "'.");
            }
        }
        return true;
    }
    
    /**
     * Return the relative path associated with this servlet.
     * 
     * @param request
     *            The servlet request we are processing
     */
    private String getRelativePath(HttpServletRequest request) {

        String result = request.getPathInfo();
        if ((result == null) || (result.equals(""))) {
            result = "/";
        }
        return ServletUtil.normalizePath(result);
    }
    
    private static class StaticMediaResource implements MediaResource {
    	
    	private final InputStream inStream;
    	private final ResourceDescriptor rd;
    	
    	public StaticMediaResource(InputStream inStream, ResourceDescriptor rd) {
    		this.inStream = inStream;
    		this.rd = rd;
    	}
    	
    	@Override
    	public boolean acceptRanges() {
    		return false;
    	}

		@Override
		public String getContentType() {
			return rd.getContentType();
		}

		@Override
		public Long getSize() {
			return rd.getSize();
		}

		@Override
		public InputStream getInputStream() {
			return inStream;
		}

		@Override
		public Long getLastModified() {
			return rd.getLastModified();
		}

		@Override
		public void prepare(HttpServletResponse hres) {
			//
		}

		@Override
		public void release() {
			IOUtils.closeQuietly(inStream);
		}
    }
}