1 package de.halbekunst.juplo.cachecontrol;
3 import java.io.IOException;
4 import java.io.OutputStream;
5 import java.io.PrintWriter;
6 import java.text.ParseException;
7 import java.text.SimpleDateFormat;
8 import java.util.Collections;
9 import java.util.Enumeration;
10 import java.util.HashMap;
11 import java.util.Locale;
13 import java.util.zip.GZIPOutputStream;
14 import javax.servlet.Filter;
15 import javax.servlet.FilterChain;
16 import javax.servlet.FilterConfig;
17 import javax.servlet.ServletException;
18 import javax.servlet.ServletOutputStream;
19 import javax.servlet.ServletRequest;
20 import javax.servlet.ServletResponse;
21 import javax.servlet.http.HttpServletRequest;
22 import javax.servlet.http.HttpServletResponse;
23 import javax.servlet.http.HttpServletResponseWrapper;
24 import org.slf4j.Logger;
25 import org.slf4j.LoggerFactory;
26 import org.springframework.beans.factory.annotation.Autowire;
27 import org.springframework.beans.factory.annotation.Autowired;
28 import org.springframework.beans.factory.annotation.Configurable;
36 @Configurable(autowire=Autowire.BY_NAME)
37 public class AcceleratorFilter implements Filter {
38 private final static Logger log = LoggerFactory.getLogger(AcceleratorFilter.class);
40 private final static Map<String,String> EMPTY = Collections.unmodifiableMap(new HashMap<String,String>());
42 public final static String REQUEST_URI_ATTRIBUTE = "javax.servlet.include.request_uri";
43 public final static String RESPONSE_WRAPPER = AcceleratorFilter.class.getName() + ".RESPONSE_WRAPPER";
46 @Autowired CacheControl cacheControl;
47 @Autowired(required=true) Integer buffer;
48 @Autowired(required=true) String eTag;
49 @Autowired(required=true) Boolean weak;
50 @Autowired(required=true) Long lastModified;
51 @Autowired(required=true) Integer cacheSeconds;
55 public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
56 if (!(request instanceof HttpServletRequest)) {
57 log.error("AcceleratorFilter can only handle HTTP-requests");
58 chain.doFilter(request, response);
62 /** Prüfen, ob es sich um eine Anfrage für einen JSP-Include handelt */
63 if (request.getAttribute(REQUEST_URI_ATTRIBUTE) != null) {
64 log.debug("Includes cannot be accelerated");
65 chain.doFilter(request, response);
69 HttpServletRequest httpRequest = (HttpServletRequest)request;
70 HttpServletResponse httpResponse = (HttpServletResponse)response;
71 AccelerationWrapper wrapper = new AccelerationWrapper(httpRequest, httpResponse);
72 httpRequest.setAttribute(RESPONSE_WRAPPER, wrapper);
73 cacheControl.init(wrapper);
74 chain.doFilter(request, wrapper);
75 /** Dekoration auslösen, falls sie bisher nicht ausgelöst wurde... */
76 cacheControl.decorate(httpRequest, httpResponse, wrapper);
81 public void init(FilterConfig filterConfig) throws ServletException {
85 public void destroy() {
89 class AccelerationWrapper extends HttpServletResponseWrapper implements CacheMethodHandle {
91 private final HttpServletRequest request;
92 private final HttpServletResponse response;
94 boolean zipped; // CacheControll greift direkt auf dieses Flag zu!
97 private GZIPServletOutputStream out;
98 private ServletOutputStream stream;
99 private PrintWriter writer;
101 private boolean guessing = true;
105 private int cacheSeconds;
106 private boolean cacheSecondsSet = false;
107 private long lastModified, expires = 0l;
109 private boolean weak;
110 private Map<String,String> cacheParams;
113 AccelerationWrapper(HttpServletRequest request, HttpServletResponse response) throws IOException {
116 this.request = request;
117 this.response = response;
119 now = System.currentTimeMillis();
120 status = HttpServletResponse.SC_OK;
121 cacheSeconds = AcceleratorFilter.this.cacheSeconds;
122 lastModified = AcceleratorFilter.this.lastModified;
123 eTag = AcceleratorFilter.this.eTag;
124 weak = AcceleratorFilter.this.weak;
125 cacheParams = new HashMap<String,String>();
127 buffer = AcceleratorFilter.this.buffer;
129 Enumeration values = request.getHeaders(Headers.HEADER_ACCEPT_ENCODING);
130 while (values.hasMoreElements()) {
131 String value = (String) values.nextElement();
132 if (value.indexOf("gzip") != -1) {
140 public void finish() throws IOException {
141 if (zipped && out != null)
147 public void setStatus(int sc) {
148 response.setStatus(sc);
151 cacheControl.decorate(request, response, this);
153 catch (Exception e) {
154 log.error("Error while decorating response", e);
159 public void setStatus(int sc, String sm) {
160 response.setStatus(sc,sm);
163 cacheControl.decorate(request, response, this);
165 catch (Exception e) {
166 log.error("Error while decorating response", e);
171 public void addDateHeader(String name, long value) {
174 super.addDateHeader(name, value);
178 if (Headers.HEADER_DATE.equalsIgnoreCase(name)) {
180 calculateCacheSeconds();
184 if (Headers.HEADER_EXPIRES.equalsIgnoreCase(name)) {
186 calculateCacheSeconds();
190 if (Headers.HEADER_LAST_MODIFIED.equalsIgnoreCase(name)) {
191 lastModified = value;
195 /** Unknown header: pass throug! */
196 super.addDateHeader(name, value);
200 public void addHeader(String name, String value) {
203 super.addHeader(name, value);
209 analyzeHeader(name, value, false);
213 public void addIntHeader(String name, int value) {
216 super.addIntHeader(name, value);
220 analyzeHeader(name, Integer.toString(value), false);
224 public void setDateHeader(String name, long value) {
227 super.setDateHeader(name, value);
231 if (Headers.HEADER_DATE.equalsIgnoreCase(name)) {
233 calculateCacheSeconds();
237 if (Headers.HEADER_EXPIRES.equalsIgnoreCase(name)) {
239 calculateCacheSeconds();
243 if (Headers.HEADER_LAST_MODIFIED.equalsIgnoreCase(name)) {
244 lastModified = value;
248 /** Unknown header: pass throug! */
249 super.setDateHeader(name, value);
253 public void setHeader(String name, String value) {
256 super.setHeader(name, value);
260 analyzeHeader(name, value, true);
264 public void setIntHeader(String name, int value) {
267 super.setIntHeader(name, value);
271 analyzeHeader(name, Integer.toString(value), true);
275 public ServletOutputStream getOutputStream() throws IOException {
278 throw new IllegalStateException("ServletOutputStream and PrintWriter cannot be requested both!");
280 if (stream == null) {
281 out = new GZIPServletOutputStream();
289 public PrintWriter getWriter() throws IOException {
292 throw new IllegalStateException("ServletOutputStream and PrintWriter cannot be requested both!");
294 if (writer == null) {
295 out = new GZIPServletOutputStream();
296 writer = new PrintWriter(out);
303 public void setContentLength(int len) {
305 log.info("Supressing explicit content-length {} for request {}, because content will be zipped!", len, request.getRequestURI());
307 response.setContentLength(len);
311 public void setBufferSize(int size) {
313 if (out != null && this.buffer != out.left)
314 throw new IllegalStateException("setBufferSize() cannot be called after content has been written!");
322 response.setBufferSize(size);
326 public void flushBuffer() throws IOException {
328 cacheControl.decorate(request, response, this);
329 response.flushBuffer();
333 public void resetBuffer() {
335 response.resetBuffer();
341 public void reset() {
348 /** Cookies has been cleared! Reinitialize decorator... */
349 cacheControl.init(this);
355 public boolean isZipped() {
356 return zipped && out != null && !out.empty;
360 public long getTimestamp() {
365 public int accepts(HttpServletRequest request) {
370 public int getCacheSeconds(HttpServletRequest request) {
375 public long getLastModified(HttpServletRequest request) {
380 public String getETag(HttpServletRequest request) {
385 public boolean isETagWeak() {
390 public void cacheControl(HttpServletRequest request, Map<String, String> cacheControlMap) {
391 cacheControlMap.putAll(cacheParams);
395 public Map<String,String> getAdditionalHeaders(HttpServletRequest request) {
399 public void supressGuessing() {
404 private void analyzeHeader(String name, String value, boolean overwrite) {
409 if (name.equalsIgnoreCase(Headers.HEADER_DATE)) {
412 now = System.currentTimeMillis();
413 cacheSeconds = AcceleratorFilter.this.cacheSeconds;
418 SimpleDateFormat parser = new SimpleDateFormat(Headers.RFC_1123_DATE_FORMAT, Locale.US);
419 now = parser.parse(value).getTime();
420 calculateCacheSeconds();
422 catch (ParseException e) {
423 log.warn("ignoring date for header \"Date\" in invalid format: {}", value);
428 if (name.equalsIgnoreCase(Headers.HEADER_EXPIRES)) {
432 cacheSeconds = AcceleratorFilter.this.cacheSeconds;
437 SimpleDateFormat parser = new SimpleDateFormat(Headers.RFC_1123_DATE_FORMAT, Locale.US);
438 expires = parser.parse(value).getTime();
439 calculateCacheSeconds();
441 catch (ParseException e) {
442 log.warn("ignoring date for header \"Expires\" in invalid format: {}", value);
447 if (name.equalsIgnoreCase(Headers.HEADER_LAST_MODIFIED)) {
450 lastModified = AcceleratorFilter.this.lastModified;
454 SimpleDateFormat parser = new SimpleDateFormat(Headers.RFC_1123_DATE_FORMAT, Locale.US);
455 lastModified = parser.parse(value).getTime();
457 catch (ParseException e) {
458 log.warn("ignoring date for header \"Last-Modified\" in invalid format: {}", value);
463 if (name.equalsIgnoreCase(Headers.HEADER_ETAG)) {
466 eTag = AcceleratorFilter.this.eTag;
467 weak = AcceleratorFilter.this.weak;
471 value = value.trim();
473 int end = value.length();
474 if (value.startsWith("W/")) {
481 if (value.charAt(start) == '"')
484 log.warn("Quote at the beginning ov ETag is missing: {}", value);
485 if (value.charAt(end -1) == '"')
488 log.warn("Quote at the end of ETag is missing: {}", value);
489 eTag = value.substring(start, end);
490 String filtered = eTag.replaceAll("[^\\x00-\\x21\\x23-\\x7F]+","");
491 if (filtered.length() < eTag.length()) {
492 log.warn("filtering out illegal characters in ETag: \"{}\" -> \"{}\"", eTag, filtered);
497 if (name.equalsIgnoreCase(Headers.HEADER_CACHE_CONTROL)) {
502 for (String param : value.split(",")) {
503 param = param.trim();
504 int pos = param.indexOf("=");
506 cacheParams.put(param, null);
509 String paramName = param.substring(0, pos).trim();
510 if (paramName.equalsIgnoreCase("max-age")) {
512 cacheSeconds = Integer.parseInt(param.substring(pos + 1));
513 cacheSecondsSet = true;
515 catch (NumberFormatException e) {
516 log.warn("illegal value for Header \"Cache-Control\":", param);
520 cacheParams.put(paramName, param.substring(pos + 1));
527 if (name.equalsIgnoreCase(Headers.HEADER_PRAGMA)) {
528 if (value != null && value.trim().equalsIgnoreCase("no-cache"))
533 /** Pass header through, if no value from intrest was found */
535 super.setHeader(name, value);
537 super.addHeader(name, value);
540 private void calculateCacheSeconds() {
541 if (!cacheSecondsSet && expires >= now) {
542 cacheSeconds = (int)(expires/1000 - now/1000);
543 log.debug("calculating cache-seconds from DATE and EXPIRES: {}", cacheSeconds);
548 class GZIPServletOutputStream extends ServletOutputStream {
550 private final OutputStream out;
551 private final GZIPOutputStream zout;
555 public GZIPServletOutputStream() throws IOException {
557 this.zout = new GZIPOutputStream(response.getOutputStream(), buffer);
558 this.out = this.zout;
562 this.out = response.getOutputStream();
570 public void close() throws IOException {
572 AcceleratorFilter.this.cacheControl.decorate(AccelerationWrapper.this.request, response, AccelerationWrapper.this);
574 catch (Exception e) {
575 log.error("Error while guessing Cache-Header's", e);
576 response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
579 if (!empty && zout != null)
585 public void flush() throws IOException {
587 AcceleratorFilter.this.cacheControl.decorate(AccelerationWrapper.this.request, response, AccelerationWrapper.this);
589 catch (Exception e) {
590 log.error("Error while guessing Cache-Header's", e);
591 response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
598 public void write(int i) throws IOException {
601 AcceleratorFilter.this.cacheControl.decorate(AccelerationWrapper.this.request, response, buffer);
603 catch (Exception e) {
604 log.error("Error while guessing Cache-Header's", e);
605 response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);