1 package de.halbekunst.juplo.cachecontrol;
3 import de.halbekunst.juplo.cachecontrol.CacheControl.CacheMethodHandle;
4 import java.io.IOException;
5 import java.io.OutputStream;
6 import java.io.PrintWriter;
7 import java.text.ParseException;
8 import java.text.SimpleDateFormat;
9 import java.util.Collections;
10 import java.util.Enumeration;
11 import java.util.HashMap;
12 import java.util.Locale;
14 import java.util.zip.GZIPOutputStream;
15 import javax.servlet.Filter;
16 import javax.servlet.FilterChain;
17 import javax.servlet.FilterConfig;
18 import javax.servlet.ServletException;
19 import javax.servlet.ServletOutputStream;
20 import javax.servlet.ServletRequest;
21 import javax.servlet.ServletResponse;
22 import javax.servlet.http.HttpServletRequest;
23 import javax.servlet.http.HttpServletResponse;
24 import javax.servlet.http.HttpServletResponseWrapper;
25 import org.slf4j.Logger;
26 import org.slf4j.LoggerFactory;
27 import org.springframework.beans.factory.annotation.Autowire;
28 import org.springframework.beans.factory.annotation.Autowired;
29 import org.springframework.beans.factory.annotation.Configurable;
37 @Configurable(autowire=Autowire.BY_NAME)
38 public class AcceleratorFilter implements Filter {
39 private final static Logger log = LoggerFactory.getLogger(AcceleratorFilter.class);
41 private final static Map<String,String> ADDITIONAL_HEADERS_NONE = Collections.unmodifiableMap(new HashMap<String,String>());
42 private final static Map<String,String> ADDITIONAL_HEADERS_GZIP;
44 public final static String REQUEST_URI_ATTRIBUTE = "javax.servlet.include.request_uri";
45 public final static String RESPONSE_WRAPPER = AcceleratorFilter.class.getName() + ".RESPONSE_WRAPPER";
48 Map<String,String> map = new HashMap<String,String>(1);
49 map.put(Headers.HEADER_CONTENT_ENCODING, "gzip");
50 ADDITIONAL_HEADERS_GZIP = Collections.unmodifiableMap(map);
54 @Autowired CacheControl cacheControl;
55 @Autowired(required=true) Integer buffer;
56 @Autowired(required=true) String eTag;
57 @Autowired(required=true) Boolean weak;
58 @Autowired(required=true) Long lastModified;
59 @Autowired(required=true) Integer cacheSeconds;
63 public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
64 if (!(request instanceof HttpServletRequest)) {
65 log.error("AcceleratorFilter can only handle HTTP-requests");
66 chain.doFilter(request, response);
70 /** Prüfen, ob es sich um eine Anfrage für einen JSP-Include handelt */
71 if (request.getAttribute(REQUEST_URI_ATTRIBUTE) != null) {
72 log.debug("Includes cannot be accelerated");
73 chain.doFilter(request, response);
77 HttpServletRequest httpRequest = (HttpServletRequest)request;
78 HttpServletResponse httpResponse = (HttpServletResponse)response;
79 AccelerationWrapper wrapper = new AccelerationWrapper(httpRequest, httpResponse);
80 httpRequest.setAttribute(RESPONSE_WRAPPER, wrapper);
81 cacheControl.init(wrapper);
82 chain.doFilter(request, wrapper);
83 /** Dekoration auslösen, falls sie bisher nicht ausgelöst wurde... */
84 cacheControl.decorate(httpRequest, httpResponse, wrapper);
89 public void init(FilterConfig filterConfig) throws ServletException {
93 public void destroy() {
97 class AccelerationWrapper extends HttpServletResponseWrapper implements CacheMethodHandle {
99 private final HttpServletRequest request;
100 private final HttpServletResponse response;
102 private boolean zipped;
104 private GZIPServletOutputStream out;
105 private ServletOutputStream stream;
106 private PrintWriter writer;
108 private boolean guessing = true;
112 private int cacheSeconds;
113 private boolean cacheSecondsSet = false;
114 private long lastModified, expires = 0l;
116 private boolean weak;
117 private Map<String,String> cacheParams;
120 AccelerationWrapper(HttpServletRequest request, HttpServletResponse response) throws IOException {
123 this.request = request;
124 this.response = response;
126 now = System.currentTimeMillis();
127 status = HttpServletResponse.SC_OK;
128 cacheSeconds = AcceleratorFilter.this.cacheSeconds;
129 lastModified = AcceleratorFilter.this.lastModified;
130 eTag = AcceleratorFilter.this.eTag;
131 weak = AcceleratorFilter.this.weak;
132 cacheParams = new HashMap<String,String>();
134 buffer = AcceleratorFilter.this.buffer;
136 Enumeration values = request.getHeaders(Headers.HEADER_ACCEPT_ENCODING);
137 while (values.hasMoreElements()) {
138 String value = (String) values.nextElement();
139 if (value.indexOf("gzip") != -1) {
147 public void finish() throws IOException {
148 if (zipped && out != null)
154 public void setStatus(int sc) {
155 response.setStatus(sc);
158 cacheControl.decorate(request, response, this);
160 catch (Exception e) {
161 log.error("Error while decorating response", e);
166 public void setStatus(int sc, String sm) {
167 response.setStatus(sc,sm);
170 cacheControl.decorate(request, response, this);
172 catch (Exception e) {
173 log.error("Error while decorating response", e);
178 public void addDateHeader(String name, long value) {
181 super.addDateHeader(name, value);
185 if (Headers.HEADER_DATE.equalsIgnoreCase(name)) {
187 calculateCacheSeconds();
191 if (Headers.HEADER_EXPIRES.equalsIgnoreCase(name)) {
193 calculateCacheSeconds();
197 if (Headers.HEADER_LAST_MODIFIED.equalsIgnoreCase(name)) {
198 lastModified = value;
202 /** Unknown header: pass throug! */
203 super.addDateHeader(name, value);
207 public void addHeader(String name, String value) {
210 super.addHeader(name, value);
216 analyzeHeader(name, value, false);
220 public void addIntHeader(String name, int value) {
223 super.addIntHeader(name, value);
227 analyzeHeader(name, Integer.toString(value), false);
231 public void setDateHeader(String name, long value) {
234 super.setDateHeader(name, value);
238 if (Headers.HEADER_DATE.equalsIgnoreCase(name)) {
240 calculateCacheSeconds();
244 if (Headers.HEADER_EXPIRES.equalsIgnoreCase(name)) {
246 calculateCacheSeconds();
250 if (Headers.HEADER_LAST_MODIFIED.equalsIgnoreCase(name)) {
251 lastModified = value;
255 /** Unknown header: pass throug! */
256 super.setDateHeader(name, value);
260 public void setHeader(String name, String value) {
263 super.setHeader(name, value);
267 analyzeHeader(name, value, true);
271 public void setIntHeader(String name, int value) {
274 super.setIntHeader(name, value);
278 analyzeHeader(name, Integer.toString(value), true);
282 public ServletOutputStream getOutputStream() throws IOException {
285 throw new IllegalStateException("ServletOutputStream and PrintWriter cannot be requested both!");
287 if (stream == null) {
288 out = new GZIPServletOutputStream();
296 public PrintWriter getWriter() throws IOException {
299 throw new IllegalStateException("ServletOutputStream and PrintWriter cannot be requested both!");
301 if (writer == null) {
302 out = new GZIPServletOutputStream();
303 writer = new PrintWriter(out);
310 public void setContentLength(int len) {
312 log.info("Supressing explicit content-length {} for request {}, because content will be zipped!", len, request.getRequestURI());
314 response.setContentLength(len);
318 public void setBufferSize(int size) {
320 if (out != null && this.buffer != out.left)
321 throw new IllegalStateException("setBufferSize() cannot be called after content has been written!");
329 response.setBufferSize(size);
333 public void flushBuffer() throws IOException {
335 cacheControl.decorate(request, response, this);
336 response.flushBuffer();
340 public void resetBuffer() {
342 response.resetBuffer();
348 public void reset() {
355 /** Cookies has been cleared! Reinitialize decorator... */
356 cacheControl.init(this);
362 public long getTimestamp() {
367 public int accepts(HttpServletRequest request) {
372 public int getCacheSeconds(HttpServletRequest request) {
377 public long getLastModified(HttpServletRequest request) {
382 public String getETag(HttpServletRequest request) {
387 public boolean isETagWeak() {
392 public void cacheControl(HttpServletRequest request, Map<String, String> cacheControlMap) {
393 cacheControlMap.putAll(cacheParams);
397 public Map<String,String> getAdditionalHeaders(HttpServletRequest request) {
398 if (zipped && !out.empty)
399 return ADDITIONAL_HEADERS_GZIP;
401 return ADDITIONAL_HEADERS_NONE;
404 public void guessingFinished() {
409 private void analyzeHeader(String name, String value, boolean overwrite) {
414 if (name.equalsIgnoreCase(Headers.HEADER_DATE)) {
417 now = System.currentTimeMillis();
418 cacheSeconds = AcceleratorFilter.this.cacheSeconds;
423 SimpleDateFormat parser = new SimpleDateFormat(Headers.RFC_1123_DATE_FORMAT, Locale.US);
424 now = parser.parse(value).getTime();
425 calculateCacheSeconds();
427 catch (ParseException e) {
428 log.warn("ignoring date for header \"Date\" in invalid format: {}", value);
433 if (name.equalsIgnoreCase(Headers.HEADER_EXPIRES)) {
437 cacheSeconds = AcceleratorFilter.this.cacheSeconds;
442 SimpleDateFormat parser = new SimpleDateFormat(Headers.RFC_1123_DATE_FORMAT, Locale.US);
443 expires = parser.parse(value).getTime();
444 calculateCacheSeconds();
446 catch (ParseException e) {
447 log.warn("ignoring date for header \"Expires\" in invalid format: {}", value);
452 if (name.equalsIgnoreCase(Headers.HEADER_LAST_MODIFIED)) {
455 lastModified = AcceleratorFilter.this.lastModified;
459 SimpleDateFormat parser = new SimpleDateFormat(Headers.RFC_1123_DATE_FORMAT, Locale.US);
460 lastModified = parser.parse(value).getTime();
462 catch (ParseException e) {
463 log.warn("ignoring date for header \"Last-Modified\" in invalid format: {}", value);
468 if (name.equalsIgnoreCase(Headers.HEADER_ETAG)) {
471 eTag = AcceleratorFilter.this.eTag;
472 weak = AcceleratorFilter.this.weak;
476 value = value.trim();
478 int end = value.length();
479 if (value.startsWith("W/")) {
486 if (value.charAt(start) == '"')
489 log.warn("Quote at the beginning ov ETag is missing: {}", value);
490 if (value.charAt(end -1) == '"')
493 log.warn("Quote at the end of ETag is missing: {}", value);
494 eTag = value.substring(start, end);
495 String filtered = eTag.replaceAll("[^\\x00-\\x21\\x23-\\x7F]+","");
496 if (filtered.length() < eTag.length()) {
497 log.warn("filtering out illegal characters in ETag: \"{}\" -> \"{}\"", eTag, filtered);
502 if (name.equalsIgnoreCase(Headers.HEADER_CACHE_CONTROL)) {
507 for (String param : value.split(",")) {
508 param = param.trim();
509 int pos = param.indexOf("=");
511 cacheParams.put(param, null);
514 String paramName = param.substring(0, pos).trim();
515 if (paramName.equalsIgnoreCase("max-age")) {
517 cacheSeconds = Integer.parseInt(param.substring(pos + 1));
518 cacheSecondsSet = true;
520 catch (NumberFormatException e) {
521 log.warn("illegal value for Header \"Cache-Control\":", param);
525 cacheParams.put(paramName, param.substring(pos + 1));
532 if (name.equalsIgnoreCase(Headers.HEADER_PRAGMA)) {
533 if (value != null && value.trim().equalsIgnoreCase("no-cache"))
538 /** Pass header through, if no value from intrest was found */
540 super.setHeader(name, value);
542 super.addHeader(name, value);
545 private void calculateCacheSeconds() {
546 if (!cacheSecondsSet && expires >= now) {
547 cacheSeconds = (int)(expires/1000 - now/1000);
548 log.debug("calculating cache-seconds from DATE and EXPIRES: {}", cacheSeconds);
553 class GZIPServletOutputStream extends ServletOutputStream {
555 private final OutputStream out;
556 private final GZIPOutputStream zout;
560 public GZIPServletOutputStream() throws IOException {
562 this.zout = new GZIPOutputStream(response.getOutputStream(), buffer);
563 this.out = this.zout;
567 this.out = response.getOutputStream();
575 public void close() throws IOException {
577 AcceleratorFilter.this.cacheControl.decorate(AccelerationWrapper.this.request, response, buffer);
579 catch (Exception e) {
580 log.error("Error while guessing Cache-Header's", e);
581 response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
584 if (!empty && zout != null)
590 public void flush() throws IOException {
592 AcceleratorFilter.this.cacheControl.decorate(AccelerationWrapper.this.request, response, buffer);
594 catch (Exception e) {
595 log.error("Error while guessing Cache-Header's", e);
596 response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
603 public void write(int i) throws IOException {
606 AcceleratorFilter.this.cacheControl.decorate(AccelerationWrapper.this.request, response, buffer);
608 catch (Exception e) {
609 log.error("Error while guessing Cache-Header's", e);
610 response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);