CateCachingFilter

package org.cateproject.view.cache;

import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Collection;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.zip.DataFormatException;

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

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import net.sf.ehcache.Ehcache;
import net.sf.ehcache.Element;
import net.sf.ehcache.constructs.blocking.LockTimeoutException;
import net.sf.ehcache.constructs.web.AlreadyCommittedException;
import net.sf.ehcache.constructs.web.AlreadyGzippedException;
import net.sf.ehcache.constructs.web.GenericResponseWrapper;
import net.sf.ehcache.constructs.web.PageInfo;
import net.sf.ehcache.constructs.web.ResponseHeadersNotModifiableException;
import net.sf.ehcache.constructs.web.ResponseUtil;
import net.sf.ehcache.constructs.web.SerializableCookie;

public abstract class CateCachingFilter {
	private static final Logger logger = LoggerFactory.getLogger(CateCachingFilter.class);

	public abstract boolean filter(final HttpServletRequest request, final HttpServletResponse response, final FilterChain chain) throws Exception;

	protected abstract String calculateKey(HttpServletRequest httpRequest) throws Exception;

	protected void doFilterInternal(final String key, final Ehcache cache, final HttpServletRequest request, final HttpServletResponse response, final FilterChain chain) throws Exception {
		PageInfo pageInfo = buildPageInfo(key,cache,request, response, chain);

        if (pageInfo.isOk()) {
            if (response.isCommitted()) {
                throw new AlreadyCommittedException("Response already committed after doing buildPage"
                        + " but before writing response from PageInfo.");
            }
            writeResponse(request, response, pageInfo);
        }
	}

	protected PageInfo buildPageInfo(final String key, final Ehcache cache, final HttpServletRequest request, final HttpServletResponse response,
			final FilterChain chain) throws Exception {

		PageInfo pageInfo = null;
		String originalThreadName = Thread.currentThread().getName();
		try {
			long start = System.currentTimeMillis();
			logger.debug("Looking for " + key);
			Element element = cache.get(key);

			if (element == null || element.getObjectValue() == null) {
				try {
					// Page is not cached - build the response, cache it, and send to client
					pageInfo = buildPage(request, response, chain, cache.getCacheConfiguration().getTimeToLiveSeconds());
					if (pageInfo.isOk()) {
						if (logger.isDebugEnabled()) {
							logger.debug("PageInfo ok. Adding to cache " + cache.getName() + " with key " + key);
						}
						cache.put(new Element(key, pageInfo));

					} else {
						if (logger.isDebugEnabled()) {
							logger.debug("PageInfo was not ok(200). Putting null into cache " + cache.getName() + " with key " + key);
						}
						cache.put(new Element(key, pageInfo));
					}
				} catch (final Throwable throwable) {
					// Must unlock the cache if the above fails. Will be logged at Filter
					cache.put(new Element(key, pageInfo));
					throw new Exception(throwable);
				}
				if (logger.isInfoEnabled()) {
			        logger.info("Cache MISS! [" + (System.currentTimeMillis() - start) + " msecs]");
				}
			} else {
				pageInfo = (PageInfo)element.getObjectValue();
				logger.info("Cache HIT! [" + (System.currentTimeMillis() - start) + " msecs]");
			}
		} catch (LockTimeoutException e) {
			//do not release the lock, because you never acquired it
			throw e;
		} finally {
			Thread.currentThread().setName(originalThreadName);
		}
		return pageInfo;
	}

	/**
     * Builds the PageInfo object by passing the request along the filter chain
     *
     * @param request
     * @param response
     * @param chain
     * @return a Serializable value object for the page or page fragment
     * @throws AlreadyGzippedException if an attempt is made to double gzip the body
     * @throws Exception
     */
    protected PageInfo buildPage(final HttpServletRequest request, final HttpServletResponse response, final FilterChain chain, long timeToLiveSeconds) throws AlreadyGzippedException, Exception {
        // Invoke the next entity in the chain
        final ByteArrayOutputStream outstr = new ByteArrayOutputStream();
        final GenericResponseWrapper wrapper = new GenericResponseWrapper(response, outstr);
        chain.doFilter(request, wrapper);
        wrapper.flush();

        // Return the page info
        return new PageInfo(wrapper.getStatus(), wrapper.getContentType(), wrapper.getHeaders(), wrapper.getCookies(),
                outstr.toByteArray(), true, timeToLiveSeconds);
    }

    /**
     * Writes the response from a PageInfo object.
     * <p/>
     * Headers are set last so that there is an opportunity to override
     *
     * @param request
     * @param response
     * @param pageInfo
     * @throws IOException
     * @throws DataFormatException
     * @throws ResponseHeadersNotModifiableException
     *
     */
    protected void writeResponse(final HttpServletRequest request, final HttpServletResponse response, final PageInfo pageInfo)
            throws IOException, DataFormatException, ResponseHeadersNotModifiableException {
        boolean requestAcceptsGzipEncoding = acceptsGzipEncoding(request);

        setStatus(response, pageInfo);
        setContentType(response, pageInfo);
        setCookies(pageInfo, response);
        //do headers last so that users can override with their own header sets
        setHeaders(pageInfo, requestAcceptsGzipEncoding, response);
        writeContent(request, response, pageInfo);
    }

    protected void setCookies(final PageInfo pageInfo, final HttpServletResponse response) {

        final Collection cookies = pageInfo.getSerializableCookies();
        for (Iterator iterator = cookies.iterator(); iterator.hasNext();) {
            final Cookie cookie = ((SerializableCookie) iterator.next()).toCookie();
            response.addCookie(cookie);
        }
    }

    protected void setHeaders(final PageInfo pageInfo,
    		boolean requestAcceptsGzipEncoding,
    		final HttpServletResponse response) {

    	final Collection headers = pageInfo.getResponseHeaders();
    	final int header = 0;
    	final int value = 1;

    	for (Iterator iterator = headers.iterator(); iterator.hasNext();) {
    		final String[] headerPair = (String[]) iterator.next();
    		response.addHeader(headerPair[header], headerPair[value]);
    	}
    }


    protected void setContentType(final HttpServletResponse response, final PageInfo pageInfo) {
        String contentType = pageInfo.getContentType();
        if (contentType != null && contentType.length() >  0) {
            response.setContentType(contentType);
        }
    }

    protected void setStatus(final HttpServletResponse response, final PageInfo pageInfo) {
        response.setStatus(pageInfo.getStatusCode());
    }

    protected boolean acceptsGzipEncoding(HttpServletRequest request) {
        return acceptsEncoding(request, "gzip");
    }

    /**
     * Checks if request accepts the named encoding.
     */
    protected boolean acceptsEncoding(final HttpServletRequest request, final String name) {
        final boolean accepts = headerContains(request, "Accept-Encoding", name);
        return accepts;
    }

    protected void writeContent(final HttpServletRequest request,
    		final HttpServletResponse response, final PageInfo pageInfo)
    throws IOException, ResponseHeadersNotModifiableException {
    	byte[] body;

    	boolean shouldBodyBeZero = ResponseUtil.shouldBodyBeZero(request, pageInfo.getStatusCode());
    	if (shouldBodyBeZero) {
    		body = new byte[0];
    	} else if (acceptsGzipEncoding(request)) {
    		body = pageInfo.getGzippedBody();
    		if (ResponseUtil.shouldGzippedBodyBeZero(body, request)) {
    			body = new byte[0];
    		} else {
    			ResponseUtil.addGzipHeader(response);
    		}

    	} else {
    		body = pageInfo.getUngzippedBody();
    	}


    	response.setContentLength(body.length);
    	OutputStream out = new BufferedOutputStream(response.getOutputStream());
    	out.write(body);
    	out.flush();
    }


    /**
     * Checks if request contains the header value.
     */
    private boolean headerContains(final HttpServletRequest request, final String header, final String value) {

        logRequestHeaders(request);

        final Enumeration accepted = request.getHeaders(header);
        while (accepted.hasMoreElements()) {
            final String headerValue = (String) accepted.nextElement();
            if (headerValue.indexOf(value) != -1) {
                return true;
            }
        }
        return false;
    }

    /**
     * Logs the request headers, if debug is enabled.
     *
     * @param request
     */
    protected void logRequestHeaders(final HttpServletRequest request) {
        if (logger.isTraceEnabled()) {
            Map headers = new HashMap();
            Enumeration enumeration = request.getHeaderNames();
            StringBuffer logLine = new StringBuffer();
            logLine.append("Request Headers");
            while (enumeration.hasMoreElements()) {
                String name = (String) enumeration.nextElement();
                String headerValue = request.getHeader(name);
                headers.put(name, headerValue);
                logLine.append(": ").append(name).append(" -> ").append(headerValue);
            }
            logger.trace(logLine.toString());
        }
    }

}