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

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