1 package de.halbekunst.juplo.cachecontrol;
3 import java.io.IOException;
4 import java.io.OutputStream;
5 import java.io.OutputStreamWriter;
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;
30 import org.springframework.beans.factory.annotation.Qualifier;
38 @Configurable(autowire=Autowire.BY_NAME)
39 public class AcceleratorFilter implements Filter {
40 private final static Logger log = LoggerFactory.getLogger(AcceleratorFilter.class);
42 private final static Map<String,String> EMPTY = Collections.unmodifiableMap(new HashMap<String,String>());
44 public final static Integer DEFAULT_BUFFER_SIZE = 1024;
45 public final static String REQUEST_URI_ATTRIBUTE = "javax.servlet.include.request_uri";
46 public final static String RESPONSE_WRAPPER = AcceleratorFilter.class.getName() + ".RESPONSE_WRAPPER";
49 @Autowired CacheControl cacheControl;
50 @Autowired(required=false) @Qualifier("defaultBufferSize") Integer defaultBufferSize = DEFAULT_BUFFER_SIZE;
51 @Autowired String eTag;
52 @Autowired Boolean weak;
53 @Autowired Long lastModified;
54 @Autowired Integer cacheSeconds;
58 public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
59 if (!(request instanceof HttpServletRequest)) {
60 log.error("AcceleratorFilter can only handle HTTP-requests");
61 chain.doFilter(request, response);
65 HttpServletRequest httpRequest = (HttpServletRequest)request;
66 HttpServletResponse httpResponse = (HttpServletResponse)response;
68 AccelerationWrapper wrapper;
70 wrapper = (AccelerationWrapper)request.getAttribute(AcceleratorFilter.RESPONSE_WRAPPER);
71 if (wrapper != null) {
72 if (wrapper.getFilter() == this) {
73 /** Ignore multiple mappings of the same filter-instance */
74 log.warn("Ignoring multiple mappings on same URL: {}", httpRequest.getRequestURI());
75 chain.doFilter(request, response);
79 log.error("Only one instance of AcceleratorFilter must be mapped to any URL: {}", httpRequest.getRequestURI());
80 httpResponse.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "Only one instance of AcceleratorFilter must be mapped to any URL!");
85 wrapper = new AccelerationWrapper(httpRequest, httpResponse);
86 httpRequest.setAttribute(RESPONSE_WRAPPER, wrapper);
87 cacheControl.init(wrapper);
89 chain.doFilter(request, wrapper);
92 catch (NotModifiedException nm) {
93 log.trace("Not modified: {}", httpRequest.getRequestURI());
98 public void init(FilterConfig filterConfig) throws ServletException {
102 public void destroy() {
106 class AccelerationWrapper implements HttpServletResponse, CacheMethodHandle {
108 private final HttpServletRequest request;
109 private final HttpServletResponse response;
111 private final AcceleratorServletOutputStream out;
113 private ServletOutputStream stream;
114 private PrintWriter writer;
116 private boolean guessing = true;
117 protected boolean zipped = false; // << CacheControll greift direkt auf diese Variable zu!
121 private int cacheSeconds;
122 private boolean cacheSecondsSet = false;
123 private long lastModified, expires = 0l;
125 private boolean weak;
126 private Map<String,String> cacheParams;
128 /** Für den AcceleratorOutputStream */
129 private boolean committed = false;
130 private OutputStream os = null;
131 private int bufferSize;
132 private byte[] buffer;
134 private int size = 0;
138 AccelerationWrapper(HttpServletRequest request, HttpServletResponse response) throws IOException {
140 this.request = request;
141 this.response = response;
143 now = System.currentTimeMillis();
144 status = HttpServletResponse.SC_OK;
145 cacheSeconds = AcceleratorFilter.this.cacheSeconds;
146 lastModified = AcceleratorFilter.this.lastModified;
147 eTag = AcceleratorFilter.this.eTag;
148 weak = AcceleratorFilter.this.weak;
149 cacheParams = new HashMap<String,String>();
151 Enumeration values = request.getHeaders(Headers.HEADER_ACCEPT_ENCODING);
152 while (values.hasMoreElements()) {
153 String value = (String) values.nextElement();
154 if (value.indexOf("gzip") != -1) {
160 out = new AcceleratorServletOutputStream();
164 private AcceleratorFilter getFilter() {
165 return AcceleratorFilter.this;
168 private void finish() throws IOException {
174 public void setStatus(int sc) {
175 response.setStatus(sc);
180 public void setStatus(int sc, String sm) {
181 response.setStatus(sc,sm);
186 public void addDateHeader(String name, long value) {
189 response.addDateHeader(name, value);
193 if (Headers.HEADER_DATE.equalsIgnoreCase(name)) {
195 calculateCacheSeconds();
199 if (Headers.HEADER_EXPIRES.equalsIgnoreCase(name)) {
201 calculateCacheSeconds();
205 if (Headers.HEADER_LAST_MODIFIED.equalsIgnoreCase(name)) {
206 lastModified = value;
210 /** Unknown header: pass throug! */
211 response.addDateHeader(name, value);
215 public void addHeader(String name, String value) {
218 response.addHeader(name, value);
224 analyzeHeader(name, value, false);
228 public void addIntHeader(String name, int value) {
231 response.addIntHeader(name, value);
235 analyzeHeader(name, Integer.toString(value), false);
239 public void setDateHeader(String name, long value) {
242 response.setDateHeader(name, value);
246 if (Headers.HEADER_DATE.equalsIgnoreCase(name)) {
248 calculateCacheSeconds();
252 if (Headers.HEADER_EXPIRES.equalsIgnoreCase(name)) {
254 calculateCacheSeconds();
258 if (Headers.HEADER_LAST_MODIFIED.equalsIgnoreCase(name)) {
259 lastModified = value;
263 /** Unknown header: pass throug! */
264 response.setDateHeader(name, value);
268 public void setHeader(String name, String value) {
271 response.setHeader(name, value);
275 analyzeHeader(name, value, true);
279 public void setIntHeader(String name, int value) {
282 response.setIntHeader(name, value);
286 analyzeHeader(name, Integer.toString(value), true);
290 public ServletOutputStream getOutputStream() throws IOException {
293 throw new IllegalStateException("ServletOutputStream and PrintWriter cannot be requested both!");
295 if (stream == null) {
303 public PrintWriter getWriter() throws IOException {
306 throw new IllegalStateException("ServletOutputStream and PrintWriter cannot be requested both!");
308 if (writer == null) {
309 writer = new PrintWriter(new OutputStreamWriter(out, response.getCharacterEncoding()));
316 public void setContentLength(int len) {
318 log.info("Supressing explicit content-length {} for request {}, because content will be zipped!", len, request.getRequestURI());
320 response.setContentLength(len);
324 public int getBufferSize() {
329 public void setBufferSize(int size) {
331 throw new IllegalStateException("cannot change buffer size, because content was already written!");
333 buffer = new byte[size];
337 public void resetBuffer() {
339 throw new IllegalStateException("cannot reset buffer, because response is already commited!");
346 public void reset() {
348 throw new IllegalStateException("cannot reset response, because response is already commited!");
350 * Da committed==false gilt, wurde die Dekoration noch nicht angestßen
351 * und muss entsprechend auch nicht rückgängig gemacht werden!
361 public void flushBuffer() throws IOException {
364 else if (stream != null)
369 public void addCookie(Cookie cookie) {
370 // TODO: Je nach Vary-Einstellung ETag anpassen?
371 response.addCookie(cookie);
375 public boolean containsHeader(String name) {
376 return response.containsHeader(name);
380 public String encodeURL(String url) {
381 return response.encodeURL(url);
385 public String encodeRedirectURL(String url) {
386 return response.encodeRedirectURL(url);
390 public String encodeUrl(String url) {
391 return response.encodeUrl(url);
395 public String encodeRedirectUrl(String url) {
396 return response.encodeRedirectUrl(url);
400 public void sendError(int sc, String msg) throws IOException {
401 response.sendError(sc,msg);
405 public void sendError(int sc) throws IOException {
406 response.sendError(sc);
410 public void sendRedirect(String location) throws IOException {
411 response.sendRedirect(location);
415 public String getCharacterEncoding() {
416 return response.getCharacterEncoding();
420 public String getContentType() {
421 return response.getContentType();
425 public void setCharacterEncoding(String charset) {
426 // TODO: Je nach Vary-Einstellung ETag anpassen?
427 response.setCharacterEncoding(charset);
431 public void setContentType(String type) {
432 // TODO: Je nach Vary-Einstellung ETag anpassen?
433 response.setContentType(type);
437 public boolean isCommitted() {
442 public void setLocale(Locale loc) {
443 // TODO: Je nach Vary-Einstellung ETag anpassen?
444 response.setLocale(loc);
448 public Locale getLocale() {
455 public boolean isZipped() {
460 public long getTimestamp() {
465 public int accepts(HttpServletRequest request) {
470 public int getCacheSeconds(HttpServletRequest request) {
475 public long getLastModified(HttpServletRequest request) {
480 public String getETag(HttpServletRequest request) {
485 public boolean isETagWeak() {
490 public void cacheControl(HttpServletRequest request, Map<String, String> cacheControlMap) {
491 cacheControlMap.putAll(cacheParams);
495 public Map<String,String> getAdditionalHeaders(HttpServletRequest request) {
499 public void supressGuessing() {
504 private void analyzeHeader(String name, String value, boolean overwrite) {
509 if (name.equalsIgnoreCase(Headers.HEADER_DATE)) {
512 now = System.currentTimeMillis();
513 cacheSeconds = AcceleratorFilter.this.cacheSeconds;
518 SimpleDateFormat parser = new SimpleDateFormat(Headers.RFC_1123_DATE_FORMAT, Locale.US);
519 now = parser.parse(value).getTime();
520 calculateCacheSeconds();
522 catch (ParseException e) {
523 log.warn("ignoring date for header \"Date\" in invalid format: {}", value);
528 if (name.equalsIgnoreCase(Headers.HEADER_EXPIRES)) {
532 cacheSeconds = AcceleratorFilter.this.cacheSeconds;
537 SimpleDateFormat parser = new SimpleDateFormat(Headers.RFC_1123_DATE_FORMAT, Locale.US);
538 expires = parser.parse(value).getTime();
539 calculateCacheSeconds();
541 catch (ParseException e) {
542 log.warn("ignoring date for header \"Expires\" in invalid format: {}", value);
547 if (name.equalsIgnoreCase(Headers.HEADER_LAST_MODIFIED)) {
550 lastModified = AcceleratorFilter.this.lastModified;
554 SimpleDateFormat parser = new SimpleDateFormat(Headers.RFC_1123_DATE_FORMAT, Locale.US);
555 lastModified = parser.parse(value).getTime();
557 catch (ParseException e) {
558 log.warn("ignoring date for header \"Last-Modified\" in invalid format: {}", value);
563 if (name.equalsIgnoreCase(Headers.HEADER_ETAG)) {
566 eTag = AcceleratorFilter.this.eTag;
567 weak = AcceleratorFilter.this.weak;
571 value = value.trim();
573 int end = value.length();
574 if (value.startsWith("W/")) {
581 if (value.charAt(start) == '"')
584 log.warn("Quote at the beginning ov ETag is missing: {}", value);
585 if (value.charAt(end -1) == '"')
588 log.warn("Quote at the end of ETag is missing: {}", value);
589 eTag = value.substring(start, end);
590 String filtered = eTag.replaceAll("[^\\x00-\\x21\\x23-\\x7F]+","");
591 if (filtered.length() < eTag.length()) {
592 log.warn("filtering out illegal characters in ETag: \"{}\" -> \"{}\"", eTag, filtered);
597 if (name.equalsIgnoreCase(Headers.HEADER_CACHE_CONTROL)) {
602 for (String param : value.split(",")) {
603 param = param.trim();
604 int pos = param.indexOf("=");
606 cacheParams.put(param, null);
609 String paramName = param.substring(0, pos).trim();
610 if (paramName.equalsIgnoreCase("max-age")) {
612 cacheSeconds = Integer.parseInt(param.substring(pos + 1));
613 cacheSecondsSet = true;
615 catch (NumberFormatException e) {
616 log.warn("illegal value for Header \"Cache-Control\":", param);
620 cacheParams.put(paramName, param.substring(pos + 1));
627 if (name.equalsIgnoreCase(Headers.HEADER_PRAGMA)) {
628 if (value != null && value.trim().equalsIgnoreCase("no-cache"))
633 /** Pass header through, if no value from intrest was found */
635 response.setHeader(name, value);
637 response.addHeader(name, value);
640 private void calculateCacheSeconds() {
641 if (!cacheSecondsSet && expires >= now) {
642 cacheSeconds = (int)(expires/1000 - now/1000);
643 log.debug("calculating cache-seconds from DATE and EXPIRES: {}", cacheSeconds);
648 private class AcceleratorServletOutputStream extends ServletOutputStream {
650 private final ServletOutputStream sos;
653 private AcceleratorServletOutputStream() throws IOException {
654 bufferSize = defaultBufferSize;
655 buffer = new byte[bufferSize];
656 sos = AccelerationWrapper.this.response.getOutputStream();
660 private OutputStream out() throws IOException {
662 os = zipped ? new GZIPOutputStream(sos) : sos;
667 public void write(int i) throws IOException {
668 if (pos == bufferSize) {
671 /** Dekoration nur beim ersten Schreib-Schub anstoßen */
673 if (!cacheControl.decorate(request, response)) {
677 throw new NotModifiedException();
682 buffer[pos++] = (byte) i;
687 public void flush() throws IOException {
692 /** Dekoration nur beim ersten Schreib-Schub anstoßen */
694 if (!cacheControl.decorate(request, response)) {
698 throw new NotModifiedException();
701 out().write(buffer, 0, pos);
707 public void close() throws IOException {
711 if (!cacheControl.decorate(request, response))
712 throw new NotModifiedException();
724 class NotModifiedException extends IOException {}