juplo.de Git - percentcodec/blob - cachecontrol/src/main/java/de/halbekunst/juplo/cachecontrol/AcceleratorFilter.java

   1 package de.halbekunst.juplo.cachecontrol;
   2
   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;
  13 import java.util.Map;
  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;
  30
  31
  32
  33 /**
  34  *
  35  * @author kai
  36  */
  37 @Configurable(autowire=Autowire.BY_NAME)
  38 public class AcceleratorFilter implements Filter {
  39   private final static Logger log = LoggerFactory.getLogger(AcceleratorFilter.class);
  40
  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;
  43
  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";
  46
  47   static {
  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);
  51   }
  52
  53
  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;
  60
  61
  62   @Override
  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);
  67       return;
  68     }
  69
  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);
  74       return;
  75     }
  76
  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);
  85     wrapper.finish();
  86   }
  87
  88   @Override
  89   public void init(FilterConfig filterConfig) throws ServletException {
  90   }
  91
  92   @Override
  93   public void destroy() {
  94   }
  95
  96
  97   class AccelerationWrapper extends HttpServletResponseWrapper implements CacheMethodHandle {
  98
  99     private final HttpServletRequest request;
 100     private final HttpServletResponse response;
 101
 102     private boolean zipped;
 103     private int buffer;
 104     private GZIPServletOutputStream out;
 105     private ServletOutputStream stream;
 106     private PrintWriter writer;
 107
 108     private boolean guessing = true;
 109
 110     private long now;
 111     private int status;
 112     private int cacheSeconds;
 113     private boolean cacheSecondsSet = false;
 114     private long lastModified, expires = 0l;
 115     private String eTag;
 116     private boolean weak;
 117     private Map<String,String> cacheParams;
 118
 119
 120     AccelerationWrapper(HttpServletRequest request, HttpServletResponse response) throws IOException {
 121       super(response);
 122
 123       this.request = request;
 124       this.response = response;
 125
 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>();
 133
 134       buffer = AcceleratorFilter.this.buffer;
 135       zipped = false;
 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) {
 140           zipped = true;
 141           break;
 142         }
 143       }
 144     }
 145
 146
 147     public void finish() throws IOException {
 148       if (zipped && out != null)
 149         out.zout.finish();
 150     }
 151
 152
 153     @Override
 154     public void setStatus(int sc) {
 155       response.setStatus(sc);
 156       status = sc;
 157       try {
 158         cacheControl.decorate(request, response, this);
 159       }
 160       catch (Exception e) {
 161         log.error("Error while decorating response", e);
 162       }
 163     }
 164
 165     @Override
 166     public void setStatus(int sc, String sm) {
 167       response.setStatus(sc,sm);
 168       status = sc;
 169       try {
 170         cacheControl.decorate(request, response, this);
 171       }
 172       catch (Exception e) {
 173         log.error("Error while decorating response", e);
 174       }
 175     }
 176
 177     @Override
 178     public void addDateHeader(String name, long value) {
 179
 180       if (!guessing) {
 181         super.addDateHeader(name, value);
 182         return;
 183       }
 184
 185       if (Headers.HEADER_DATE.equalsIgnoreCase(name)) {
 186         now = value;
 187         calculateCacheSeconds();
 188         return;
 189       }
 190
 191       if (Headers.HEADER_EXPIRES.equalsIgnoreCase(name)) {
 192         expires = value;
 193         calculateCacheSeconds();
 194         return;
 195       }
 196
 197       if (Headers.HEADER_LAST_MODIFIED.equalsIgnoreCase(name)) {
 198         lastModified = value;
 199         return;
 200       }
 201
 202       /** Unknown header: pass throug! */
 203       super.addDateHeader(name, value);
 204     }
 205
 206     @Override
 207     public void addHeader(String name, String value) {
 208
 209       if (!guessing) {
 210         super.addHeader(name, value);
 211         return;
 212       }
 213
 214       if (value == null)
 215         return;
 216       analyzeHeader(name, value, false);
 217     }
 218
 219     @Override
 220     public void addIntHeader(String name, int value) {
 221
 222       if (!guessing) {
 223         super.addIntHeader(name, value);
 224         return;
 225       }
 226
 227       analyzeHeader(name, Integer.toString(value), false);
 228     }
 229
 230     @Override
 231     public void setDateHeader(String name, long value) {
 232
 233       if (!guessing) {
 234         super.setDateHeader(name, value);
 235         return;
 236       }
 237
 238       if (Headers.HEADER_DATE.equalsIgnoreCase(name)) {
 239         now = value;
 240         calculateCacheSeconds();
 241         return;
 242       }
 243
 244       if (Headers.HEADER_EXPIRES.equalsIgnoreCase(name)) {
 245         expires = value;
 246         calculateCacheSeconds();
 247         return;
 248       }
 249
 250       if (Headers.HEADER_LAST_MODIFIED.equalsIgnoreCase(name)) {
 251         lastModified = value;
 252         return;
 253       }
 254
 255       /** Unknown header: pass throug! */
 256       super.setDateHeader(name, value);
 257     }
 258
 259     @Override
 260     public void setHeader(String name, String value) {
 261
 262       if (!guessing) {
 263         super.setHeader(name, value);
 264         return;
 265       }
 266
 267       analyzeHeader(name, value, true);
 268     }
 269
 270     @Override
 271     public void setIntHeader(String name, int value) {
 272
 273       if (!guessing) {
 274         super.setIntHeader(name, value);
 275         return;
 276       }
 277
 278       analyzeHeader(name, Integer.toString(value), true);
 279     }
 280
 281     @Override
 282     public ServletOutputStream getOutputStream() throws IOException {
 283
 284       if (writer != null)
 285         throw new IllegalStateException("ServletOutputStream and PrintWriter cannot be requested both!");
 286
 287       if (stream == null) {
 288         out = new GZIPServletOutputStream();
 289         stream = out;
 290       }
 291
 292       return out;
 293     }
 294
 295     @Override
 296     public PrintWriter getWriter() throws IOException {
 297
 298       if (stream != null)
 299         throw new IllegalStateException("ServletOutputStream and PrintWriter cannot be requested both!");
 300
 301       if (writer == null) {
 302         out = new GZIPServletOutputStream();
 303         writer = new PrintWriter(out);
 304       }
 305
 306       return writer;
 307     }
 308
 309     @Override
 310     public void setContentLength(int len) {
 311       if (zipped)
 312         log.info("Supressing explicit content-length {} for request {}, because content will be zipped!", len, request.getRequestURI());
 313       else
 314         response.setContentLength(len);
 315     }
 316
 317     @Override
 318     public void setBufferSize(int size) {
 319
 320       if (out != null && this.buffer != out.left)
 321         throw new IllegalStateException("setBufferSize() cannot be called after content has been written!");
 322
 323       if (size < 0)
 324         size = 0;
 325
 326       this.buffer = size;
 327       if (out != null)
 328         out.left = size;
 329       response.setBufferSize(size);
 330     }
 331
 332     @Override
 333     public void flushBuffer() throws IOException {
 334
 335       cacheControl.decorate(request, response, this);
 336       response.flushBuffer();
 337     }
 338
 339     @Override
 340     public void resetBuffer() {
 341
 342       response.resetBuffer();
 343       stream = null;
 344       writer = null;
 345     }
 346
 347     @Override
 348     public void reset() {
 349
 350       response.reset();
 351       out = null;
 352       stream = null;
 353       writer = null;
 354
 355       /** Cookies has been cleared! Reinitialize decorator... */
 356       cacheControl.init(this);
 357     }
 358
 359
 360
 361     @Override
 362     public long getTimestamp() {
 363       return now;
 364     }
 365
 366     @Override
 367     public int accepts(HttpServletRequest request) {
 368       return status;
 369     }
 370
 371     @Override
 372     public int getCacheSeconds(HttpServletRequest request) {
 373       return cacheSeconds;
 374     }
 375
 376     @Override
 377     public long getLastModified(HttpServletRequest request) {
 378       return lastModified;
 379     }
 380
 381     @Override
 382     public String getETag(HttpServletRequest request) {
 383       return eTag;
 384     }
 385
 386     @Override
 387     public boolean isETagWeak() {
 388       return weak;
 389     }
 390
 391     @Override
 392     public void cacheControl(HttpServletRequest request, Map<String, String> cacheControlMap) {
 393       cacheControlMap.putAll(cacheParams);
 394     }
 395
 396     @Override
 397     public Map<String,String> getAdditionalHeaders(HttpServletRequest request) {
 398       if (zipped && !out.empty)
 399         return ADDITIONAL_HEADERS_GZIP;
 400       else
 401         return ADDITIONAL_HEADERS_NONE;
 402     }
 403
 404     public void guessingFinished() {
 405       guessing = false;
 406     }
 407
 408
 409     private void analyzeHeader(String name, String value, boolean overwrite) {
 410       if (name == null)
 411         return;
 412       name = name.trim();
 413
 414       if (name.equalsIgnoreCase(Headers.HEADER_DATE)) {
 415         if (value == null) {
 416           if (overwrite) {
 417             now = System.currentTimeMillis();
 418             cacheSeconds = AcceleratorFilter.this.cacheSeconds;
 419           }
 420           return;
 421         }
 422         try {
 423           SimpleDateFormat parser = new SimpleDateFormat(Headers.RFC_1123_DATE_FORMAT, Locale.US);
 424           now = parser.parse(value).getTime();
 425           calculateCacheSeconds();
 426         }
 427         catch (ParseException e) {
 428           log.warn("ignoring date for header \"Date\" in invalid format: {}", value);
 429         }
 430         return;
 431       }
 432
 433       if (name.equalsIgnoreCase(Headers.HEADER_EXPIRES)) {
 434         if (value == null) {
 435           if (overwrite) {
 436             expires = 0;
 437             cacheSeconds = AcceleratorFilter.this.cacheSeconds;
 438           }
 439           return;
 440         }
 441         try {
 442           SimpleDateFormat parser = new SimpleDateFormat(Headers.RFC_1123_DATE_FORMAT, Locale.US);
 443           expires = parser.parse(value).getTime();
 444           calculateCacheSeconds();
 445         }
 446         catch (ParseException e) {
 447           log.warn("ignoring date for header \"Expires\" in invalid format: {}", value);
 448         }
 449         return;
 450       }
 451
 452       if (name.equalsIgnoreCase(Headers.HEADER_LAST_MODIFIED)) {
 453         if (value == null) {
 454           if (overwrite)
 455             lastModified = AcceleratorFilter.this.lastModified;
 456           return;
 457         }
 458         try {
 459           SimpleDateFormat parser = new SimpleDateFormat(Headers.RFC_1123_DATE_FORMAT, Locale.US);
 460           lastModified = parser.parse(value).getTime();
 461         }
 462         catch (ParseException e) {
 463           log.warn("ignoring date for header \"Last-Modified\" in invalid format: {}", value);
 464         }
 465         return;
 466       }
 467
 468       if (name.equalsIgnoreCase(Headers.HEADER_ETAG)) {
 469         if (value == null) {
 470           if (overwrite) {
 471             eTag = AcceleratorFilter.this.eTag;
 472             weak = AcceleratorFilter.this.weak;
 473           }
 474           return;
 475         }
 476         value = value.trim();
 477         int start = 0;
 478         int end = value.length();
 479         if (value.startsWith("W/")) {
 480           weak = true;
 481           start = 2;
 482         }
 483         else {
 484           weak = false;
 485         }
 486         if (value.charAt(start) == '"')
 487           start++;
 488         else
 489           log.warn("Quote at the beginning ov ETag is missing: {}", value);
 490         if (value.charAt(end -1) == '"')
 491           end--;
 492         else
 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);
 498           eTag = filtered;
 499         }
 500       }
 501
 502       if (name.equalsIgnoreCase(Headers.HEADER_CACHE_CONTROL)) {
 503         if (overwrite)
 504           cacheParams.clear();
 505         if (value == null)
 506           return;
 507         for (String param : value.split(",")) {
 508           param = param.trim();
 509           int pos = param.indexOf("=");
 510           if (pos < 0) {
 511             cacheParams.put(param, null);
 512           }
 513           else {
 514             String paramName = param.substring(0, pos).trim();
 515             if (paramName.equalsIgnoreCase("max-age")) {
 516               try {
 517                 cacheSeconds = Integer.parseInt(param.substring(pos + 1));
 518                 cacheSecondsSet = true;
 519               }
 520               catch (NumberFormatException e) {
 521                 log.warn("illegal value for Header \"Cache-Control\":", param);
 522               }
 523             }
 524             else {
 525               cacheParams.put(paramName, param.substring(pos + 1));
 526             }
 527           }
 528         }
 529         return;
 530       }
 531
 532       if (name.equalsIgnoreCase(Headers.HEADER_PRAGMA)) {
 533         if (value != null && value.trim().equalsIgnoreCase("no-cache"))
 534           cacheSeconds = 0;
 535         return;
 536       }
 537
 538       /** Pass header through, if no value from intrest was found */
 539       if (overwrite)
 540         super.setHeader(name, value);
 541       else
 542         super.addHeader(name, value);
 543     }
 544
 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);
 549       }
 550     }
 551
 552
 553     class GZIPServletOutputStream extends ServletOutputStream {
 554
 555       private final OutputStream out;
 556       private final GZIPOutputStream zout;
 557       int left;
 558       boolean empty;
 559
 560       public GZIPServletOutputStream() throws IOException {
 561         if (zipped) {
 562           this.zout = new GZIPOutputStream(response.getOutputStream(), buffer);
 563           this.out = this.zout;
 564         }
 565         else {
 566           this.zout = null;
 567           this.out = response.getOutputStream();
 568         }
 569         empty = true;
 570         left = buffer;
 571       }
 572
 573
 574       @Override
 575       public void close() throws IOException {
 576         try {
 577           AcceleratorFilter.this.cacheControl.decorate(AccelerationWrapper.this.request, response, buffer);
 578         }
 579         catch (Exception e) {
 580           log.error("Error while guessing Cache-Header's", e);
 581           response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 582         }
 583
 584         if (!empty && zout != null)
 585           zout.finish();
 586         out.close();
 587       }
 588
 589       @Override
 590       public void flush() throws IOException {
 591         try {
 592           AcceleratorFilter.this.cacheControl.decorate(AccelerationWrapper.this.request, response, buffer);
 593         }
 594         catch (Exception e) {
 595           log.error("Error while guessing Cache-Header's", e);
 596           response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 597         }
 598
 599         out.flush();
 600       }
 601
 602       @Override
 603       public void write(int i) throws IOException {
 604         if (left == 0) {
 605           try {
 606             AcceleratorFilter.this.cacheControl.decorate(AccelerationWrapper.this.request, response, buffer);
 607           }
 608           catch (Exception e) {
 609             log.error("Error while guessing Cache-Header's", e);
 610             response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 611           }
 612         }
 613         empty = false;
 614         left--;
 615         out.write(i);
 616       }
 617     }
 618   }
 619 }