1 package de.halbekunst.juplo.cachecontrol;
3 import java.io.ByteArrayOutputStream;
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.Cookie;
23 import javax.servlet.http.HttpServletRequest;
24 import javax.servlet.http.HttpServletResponse;
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> EMPTY = Collections.unmodifiableMap(new HashMap<String,String>());
43 public final static String REQUEST_URI_ATTRIBUTE = "javax.servlet.include.request_uri";
44 public final static String RESPONSE_WRAPPER = AcceleratorFilter.class.getName() + ".RESPONSE_WRAPPER";
47 @Autowired CacheControl cacheControl;
48 @Autowired(required=true) Integer buffer;
49 @Autowired(required=true) String eTag;
50 @Autowired(required=true) Boolean weak;
51 @Autowired(required=true) Long lastModified;
52 @Autowired(required=true) Integer cacheSeconds;
56 public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
57 if (!(request instanceof HttpServletRequest)) {
58 log.error("AcceleratorFilter can only handle HTTP-requests");
59 chain.doFilter(request, response);
63 /** Prüfen, ob es sich um eine Anfrage für einen JSP-Include handelt */
64 if (request.getAttribute(REQUEST_URI_ATTRIBUTE) != null) {
65 log.debug("Includes cannot be accelerated");
66 chain.doFilter(request, response);
70 HttpServletRequest httpRequest = (HttpServletRequest)request;
71 HttpServletResponse httpResponse = (HttpServletResponse)response;
72 AccelerationWrapper wrapper = new AccelerationWrapper(httpRequest, httpResponse);
73 httpRequest.setAttribute(RESPONSE_WRAPPER, wrapper);
74 cacheControl.init(wrapper);
75 chain.doFilter(request, wrapper);
80 public void init(FilterConfig filterConfig) throws ServletException {
84 public void destroy() {
88 class AccelerationWrapper implements HttpServletResponse, CacheMethodHandle {
90 private final HttpServletRequest request;
91 private final HttpServletResponse response;
93 boolean zipped; // CacheControll greift direkt auf dieses Flag zu!
94 boolean forceCompression = false;
96 private CountingServletOutputStream out;
97 private ServletOutputStream stream;
98 private PrintWriter writer;
100 private boolean guessing = true;
104 private int cacheSeconds;
105 private boolean cacheSecondsSet = false;
106 private long lastModified, expires = 0l;
108 private boolean weak;
109 private Map<String,String> cacheParams;
112 AccelerationWrapper(HttpServletRequest request, HttpServletResponse response) throws IOException {
114 this.request = request;
115 this.response = response;
117 now = System.currentTimeMillis();
118 status = HttpServletResponse.SC_OK;
119 cacheSeconds = AcceleratorFilter.this.cacheSeconds;
120 lastModified = AcceleratorFilter.this.lastModified;
121 eTag = AcceleratorFilter.this.eTag;
122 weak = AcceleratorFilter.this.weak;
123 cacheParams = new HashMap<String,String>();
126 Enumeration values = request.getHeaders(Headers.HEADER_ACCEPT_ENCODING);
127 while (values.hasMoreElements()) {
128 String value = (String) values.nextElement();
129 if (value.indexOf("gzip") != -1) {
135 out = new GZIPServletOutputStream();
137 out = new CountingServletOutputStream();
140 public void finish() throws IOException {
146 public void setStatus(int sc) {
147 response.setStatus(sc);
150 cacheControl.decorate(request, response, this);
152 catch (Exception e) {
153 log.error("Error while decorating response", e);
158 public void setStatus(int sc, String sm) {
159 response.setStatus(sc,sm);
162 cacheControl.decorate(request, response, this);
164 catch (Exception e) {
165 log.error("Error while decorating response", e);
170 public void addDateHeader(String name, long value) {
173 response.addDateHeader(name, value);
177 if (Headers.HEADER_DATE.equalsIgnoreCase(name)) {
179 calculateCacheSeconds();
183 if (Headers.HEADER_EXPIRES.equalsIgnoreCase(name)) {
185 calculateCacheSeconds();
189 if (Headers.HEADER_LAST_MODIFIED.equalsIgnoreCase(name)) {
190 lastModified = value;
194 /** Unknown header: pass throug! */
195 response.addDateHeader(name, value);
199 public void addHeader(String name, String value) {
202 response.addHeader(name, value);
208 analyzeHeader(name, value, false);
212 public void addIntHeader(String name, int value) {
215 response.addIntHeader(name, value);
219 analyzeHeader(name, Integer.toString(value), false);
223 public void setDateHeader(String name, long value) {
226 response.setDateHeader(name, value);
230 if (Headers.HEADER_DATE.equalsIgnoreCase(name)) {
232 calculateCacheSeconds();
236 if (Headers.HEADER_EXPIRES.equalsIgnoreCase(name)) {
238 calculateCacheSeconds();
242 if (Headers.HEADER_LAST_MODIFIED.equalsIgnoreCase(name)) {
243 lastModified = value;
247 /** Unknown header: pass throug! */
248 response.setDateHeader(name, value);
252 public void setHeader(String name, String value) {
255 response.setHeader(name, value);
259 analyzeHeader(name, value, true);
263 public void setIntHeader(String name, int value) {
266 response.setIntHeader(name, value);
270 analyzeHeader(name, Integer.toString(value), true);
274 public ServletOutputStream getOutputStream() throws IOException {
277 throw new IllegalStateException("ServletOutputStream and PrintWriter cannot be requested both!");
279 if (stream == null) {
287 public PrintWriter getWriter() throws IOException {
290 throw new IllegalStateException("ServletOutputStream and PrintWriter cannot be requested both!");
292 if (writer == null) {
293 writer = new PrintWriter(out);
300 public void setContentLength(int len) {
302 log.info("Supressing explicit content-length {} for request {}, because content will be zipped!", len, request.getRequestURI());
304 response.setContentLength(len);
308 public void setBufferSize(int size) {
311 response.setBufferSize(size);
315 public void flushBuffer() throws IOException {
317 forceCompression = true;
318 cacheControl.decorate(request, response, this);
319 response.flushBuffer();
323 public void resetBuffer() {
325 response.resetBuffer();
328 out = new GZIPServletOutputStream();
330 out = new CountingServletOutputStream();
332 catch (IOException e) {
333 throw new IllegalStateException(e);
340 public void reset() {
345 out = new GZIPServletOutputStream();
347 out = new CountingServletOutputStream();
349 catch (IOException e) {
350 throw new IllegalStateException(e);
355 /** Cookies has been cleared! Reinitialize decorator... */
356 forceCompression = false;
357 cacheControl.init(this);
363 public boolean isZipped() {
364 return out.isZipped();
368 public long getTimestamp() {
373 public int accepts(HttpServletRequest request) {
378 public int getCacheSeconds(HttpServletRequest request) {
383 public long getLastModified(HttpServletRequest request) {
388 public String getETag(HttpServletRequest request) {
393 public boolean isETagWeak() {
398 public void cacheControl(HttpServletRequest request, Map<String, String> cacheControlMap) {
399 cacheControlMap.putAll(cacheParams);
403 public Map<String,String> getAdditionalHeaders(HttpServletRequest request) {
407 public void supressGuessing() {
412 private void analyzeHeader(String name, String value, boolean overwrite) {
417 if (name.equalsIgnoreCase(Headers.HEADER_DATE)) {
420 now = System.currentTimeMillis();
421 cacheSeconds = AcceleratorFilter.this.cacheSeconds;
426 SimpleDateFormat parser = new SimpleDateFormat(Headers.RFC_1123_DATE_FORMAT, Locale.US);
427 now = parser.parse(value).getTime();
428 calculateCacheSeconds();
430 catch (ParseException e) {
431 log.warn("ignoring date for header \"Date\" in invalid format: {}", value);
436 if (name.equalsIgnoreCase(Headers.HEADER_EXPIRES)) {
440 cacheSeconds = AcceleratorFilter.this.cacheSeconds;
445 SimpleDateFormat parser = new SimpleDateFormat(Headers.RFC_1123_DATE_FORMAT, Locale.US);
446 expires = parser.parse(value).getTime();
447 calculateCacheSeconds();
449 catch (ParseException e) {
450 log.warn("ignoring date for header \"Expires\" in invalid format: {}", value);
455 if (name.equalsIgnoreCase(Headers.HEADER_LAST_MODIFIED)) {
458 lastModified = AcceleratorFilter.this.lastModified;
462 SimpleDateFormat parser = new SimpleDateFormat(Headers.RFC_1123_DATE_FORMAT, Locale.US);
463 lastModified = parser.parse(value).getTime();
465 catch (ParseException e) {
466 log.warn("ignoring date for header \"Last-Modified\" in invalid format: {}", value);
471 if (name.equalsIgnoreCase(Headers.HEADER_ETAG)) {
474 eTag = AcceleratorFilter.this.eTag;
475 weak = AcceleratorFilter.this.weak;
479 value = value.trim();
481 int end = value.length();
482 if (value.startsWith("W/")) {
489 if (value.charAt(start) == '"')
492 log.warn("Quote at the beginning ov ETag is missing: {}", value);
493 if (value.charAt(end -1) == '"')
496 log.warn("Quote at the end of ETag is missing: {}", value);
497 eTag = value.substring(start, end);
498 String filtered = eTag.replaceAll("[^\\x00-\\x21\\x23-\\x7F]+","");
499 if (filtered.length() < eTag.length()) {
500 log.warn("filtering out illegal characters in ETag: \"{}\" -> \"{}\"", eTag, filtered);
505 if (name.equalsIgnoreCase(Headers.HEADER_CACHE_CONTROL)) {
510 for (String param : value.split(",")) {
511 param = param.trim();
512 int pos = param.indexOf("=");
514 cacheParams.put(param, null);
517 String paramName = param.substring(0, pos).trim();
518 if (paramName.equalsIgnoreCase("max-age")) {
520 cacheSeconds = Integer.parseInt(param.substring(pos + 1));
521 cacheSecondsSet = true;
523 catch (NumberFormatException e) {
524 log.warn("illegal value for Header \"Cache-Control\":", param);
528 cacheParams.put(paramName, param.substring(pos + 1));
535 if (name.equalsIgnoreCase(Headers.HEADER_PRAGMA)) {
536 if (value != null && value.trim().equalsIgnoreCase("no-cache"))
541 /** Pass header through, if no value from intrest was found */
543 response.setHeader(name, value);
545 response.addHeader(name, value);
548 private void calculateCacheSeconds() {
549 if (!cacheSecondsSet && expires >= now) {
550 cacheSeconds = (int)(expires/1000 - now/1000);
551 log.debug("calculating cache-seconds from DATE and EXPIRES: {}", cacheSeconds);
556 public void addCookie(Cookie cookie) {
557 // TODO: Je nach Vary-Einstellung ETag anpassen?
558 response.addCookie(cookie);
562 public boolean containsHeader(String name) {
563 return response.containsHeader(name);
567 public String encodeURL(String url) {
568 return response.encodeURL(url);
572 public String encodeRedirectURL(String url) {
573 return response.encodeRedirectURL(url);
577 public String encodeUrl(String url) {
578 return response.encodeUrl(url);
582 public String encodeRedirectUrl(String url) {
583 return response.encodeRedirectUrl(url);
587 public void sendError(int sc, String msg) throws IOException {
588 // TODO: Decoration anpassen/anstoßen?!?
589 response.sendError(sc,msg);
593 public void sendError(int sc) throws IOException {
594 // TODO: Decoration anpassen/anstoßen?!?
595 response.sendError(sc);
599 public void sendRedirect(String location) throws IOException {
600 // TODO: Decoration anpassen/anstoßen?!?
601 response.sendRedirect(location);
605 public String getCharacterEncoding() {
606 return response.getCharacterEncoding();
610 public String getContentType() {
611 return response.getContentType();
615 public void setCharacterEncoding(String charset) {
616 // TODO: Je nach Vary-Einstellung ETag anpassen?
617 response.setCharacterEncoding(charset);
621 public void setContentType(String type) {
622 // TODO: Je nach Vary-Einstellung ETag anpassen?
623 response.setContentType(type);
627 public int getBufferSize() {
628 return response.getBufferSize();
632 public boolean isCommitted() {
633 // TODO: Eigene commit-Kontrolle wegen Dekorations-Einstiegspunkt?!?
634 return response.isCommitted();
638 public void setLocale(Locale loc) {
639 // TODO: Je nach Vary-Einstellung ETag anpassen?
640 response.setLocale(loc);
644 public Locale getLocale() {
649 class CountingServletOutputStream extends ServletOutputStream {
651 private OutputStream out;
656 CountingServletOutputStream() throws IOException {
657 out = response.getOutputStream();
663 void setBuffer(int size) throws IllegalStateException {}
669 void finish() throws IOException {
673 void decorate() throws IOException {
675 AcceleratorFilter.this.cacheControl.decorate(AccelerationWrapper.this.request, response, AccelerationWrapper.this);
677 catch (Exception e) {
678 log.error("Error while guessing Cache-Header's", e);
679 response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
685 public void close() throws IOException {
691 public void flush() throws IOException {
697 public void write(int i) throws IOException {
707 final class GZIPServletOutputStream extends CountingServletOutputStream {
709 final static int MINIMAL_BUFFER_SIZE = 128;
711 private ByteArrayOutputStream buffer;
712 private OutputStream out;
713 private GZIPOutputStream zout;
714 private int bufferSize;
715 private boolean decorated = false;
718 public GZIPServletOutputStream() throws IOException {
719 setBuffer(AcceleratorFilter.this.buffer);
724 void finish() throws IOException {
727 super.out.write(buffer.toByteArray());
738 void setBuffer(int size) throws IllegalStateException {
740 throw new IllegalStateException("attemp to change buffer size after writing data to response!");
742 if (size > MINIMAL_BUFFER_SIZE) {
746 out = response.getOutputStream();
747 buffer = new ByteArrayOutputStream(size);
748 zout = new GZIPOutputStream(buffer, size);
751 catch (IOException e) {
752 throw new IllegalStateException(e);
760 public void close() throws IOException {
763 out.write(buffer.toByteArray());
768 public void flush() throws IOException {
770 out.write(buffer.toByteArray());
775 public void write(int i) throws IOException {
782 out.write(buffer.toByteArray());