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.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;
  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.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;
  31
  32
  33
  34 /**
  35  *
  36  * @author kai
  37  */
  38 @Configurable(autowire=Autowire.BY_NAME)
  39 public class AcceleratorFilter implements Filter {
  40   private final static Logger log = LoggerFactory.getLogger(AcceleratorFilter.class);
  41
  42   private final static Map<String,String> EMPTY = Collections.unmodifiableMap(new HashMap<String,String>());
  43
  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";
  47
  48
  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;
  55
  56
  57   @Override
  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);
  62       return;
  63     }
  64
  65     // TODO: Das macht so wahrscheinlich keinen Sinn...
  66     /** Prüfen, ob es sich um eine Anfrage für einen JSP-Include handelt */
  67     if (request.getAttribute(REQUEST_URI_ATTRIBUTE) != null) {
  68       log.debug("Includes cannot be accelerated");
  69       chain.doFilter(request, response);
  70       return;
  71     }
  72
  73     HttpServletRequest httpRequest = (HttpServletRequest)request;
  74     HttpServletResponse httpResponse = (HttpServletResponse)response;
  75     AccelerationWrapper wrapper = new AccelerationWrapper(httpRequest, httpResponse);
  76     httpRequest.setAttribute(RESPONSE_WRAPPER, wrapper);
  77     cacheControl.init(wrapper);
  78     chain.doFilter(request, wrapper);
  79     wrapper.finish();
  80   }
  81
  82   @Override
  83   public void init(FilterConfig filterConfig) throws ServletException {
  84   }
  85
  86   @Override
  87   public void destroy() {
  88   }
  89
  90
  91   class AccelerationWrapper implements HttpServletResponse, CacheMethodHandle {
  92
  93     private final HttpServletRequest request;
  94     private final HttpServletResponse response;
  95
  96     private final AcceleratorServletOutputStream out;
  97
  98     private ServletOutputStream stream;
  99     private PrintWriter writer;
 100
 101     private boolean guessing = true;
 102     protected boolean zipped = false; // << CacheControll greift direkt auf diese Variable zu!
 103
 104     private long now;
 105     private int status;
 106     private int cacheSeconds;
 107     private boolean cacheSecondsSet = false;
 108     private long lastModified, expires = 0l;
 109     private String eTag;
 110     private boolean weak;
 111     private Map<String,String> cacheParams;
 112
 113     /** Für den AcceleratorOutputStream */
 114     private boolean committed = false;
 115     private OutputStream os = null;
 116     private int bufferSize;
 117     private byte[] buffer;
 118     private int pos = 0;
 119     private int size = 0;
 120
 121
 122
 123     AccelerationWrapper(HttpServletRequest request, HttpServletResponse response) throws IOException {
 124
 125       this.request = request;
 126       this.response = response;
 127
 128       now = System.currentTimeMillis();
 129       status = HttpServletResponse.SC_OK;
 130       cacheSeconds = AcceleratorFilter.this.cacheSeconds;
 131       lastModified = AcceleratorFilter.this.lastModified;
 132       eTag = AcceleratorFilter.this.eTag;
 133       weak = AcceleratorFilter.this.weak;
 134       cacheParams = new HashMap<String,String>();
 135
 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       out = new AcceleratorServletOutputStream();
 146     }
 147
 148
 149     private void finish() throws IOException {
 150       flushBuffer();
 151       out.close();
 152     }
 153
 154     @Override
 155     public void setStatus(int sc) {
 156       response.setStatus(sc);
 157       status = sc;
 158     }
 159
 160     @Override
 161     public void setStatus(int sc, String sm) {
 162       response.setStatus(sc,sm);
 163       status = sc;
 164     }
 165
 166     @Override
 167     public void addDateHeader(String name, long value) {
 168
 169       if (!guessing) {
 170         response.addDateHeader(name, value);
 171         return;
 172       }
 173
 174       if (Headers.HEADER_DATE.equalsIgnoreCase(name)) {
 175         now = value;
 176         calculateCacheSeconds();
 177         return;
 178       }
 179
 180       if (Headers.HEADER_EXPIRES.equalsIgnoreCase(name)) {
 181         expires = value;
 182         calculateCacheSeconds();
 183         return;
 184       }
 185
 186       if (Headers.HEADER_LAST_MODIFIED.equalsIgnoreCase(name)) {
 187         lastModified = value;
 188         return;
 189       }
 190
 191       /** Unknown header: pass throug! */
 192       response.addDateHeader(name, value);
 193     }
 194
 195     @Override
 196     public void addHeader(String name, String value) {
 197
 198       if (!guessing) {
 199         response.addHeader(name, value);
 200         return;
 201       }
 202
 203       if (value == null)
 204         return;
 205       analyzeHeader(name, value, false);
 206     }
 207
 208     @Override
 209     public void addIntHeader(String name, int value) {
 210
 211       if (!guessing) {
 212         response.addIntHeader(name, value);
 213         return;
 214       }
 215
 216       analyzeHeader(name, Integer.toString(value), false);
 217     }
 218
 219     @Override
 220     public void setDateHeader(String name, long value) {
 221
 222       if (!guessing) {
 223         response.setDateHeader(name, value);
 224         return;
 225       }
 226
 227       if (Headers.HEADER_DATE.equalsIgnoreCase(name)) {
 228         now = value;
 229         calculateCacheSeconds();
 230         return;
 231       }
 232
 233       if (Headers.HEADER_EXPIRES.equalsIgnoreCase(name)) {
 234         expires = value;
 235         calculateCacheSeconds();
 236         return;
 237       }
 238
 239       if (Headers.HEADER_LAST_MODIFIED.equalsIgnoreCase(name)) {
 240         lastModified = value;
 241         return;
 242       }
 243
 244       /** Unknown header: pass throug! */
 245       response.setDateHeader(name, value);
 246     }
 247
 248     @Override
 249     public void setHeader(String name, String value) {
 250
 251       if (!guessing) {
 252         response.setHeader(name, value);
 253         return;
 254       }
 255
 256       analyzeHeader(name, value, true);
 257     }
 258
 259     @Override
 260     public void setIntHeader(String name, int value) {
 261
 262       if (!guessing) {
 263         response.setIntHeader(name, value);
 264         return;
 265       }
 266
 267       analyzeHeader(name, Integer.toString(value), true);
 268     }
 269
 270     @Override
 271     public ServletOutputStream getOutputStream() throws IOException {
 272
 273       if (writer != null)
 274         throw new IllegalStateException("ServletOutputStream and PrintWriter cannot be requested both!");
 275
 276       if (stream == null) {
 277         stream = out;
 278       }
 279
 280       return out;
 281     }
 282
 283     @Override
 284     public PrintWriter getWriter() throws IOException {
 285
 286       if (stream != null)
 287         throw new IllegalStateException("ServletOutputStream and PrintWriter cannot be requested both!");
 288
 289       if (writer == null) {
 290         writer = new PrintWriter(new OutputStreamWriter(out, response.getCharacterEncoding()));
 291       }
 292
 293       return writer;
 294     }
 295
 296     @Override
 297     public void setContentLength(int len) {
 298       if (zipped)
 299         log.info("Supressing explicit content-length {} for request {}, because content will be zipped!", len, request.getRequestURI());
 300       else
 301         response.setContentLength(len);
 302     }
 303
 304     @Override
 305     public int getBufferSize() {
 306       return bufferSize;
 307     }
 308
 309     @Override
 310     public void setBufferSize(int size) {
 311       if (this.size > 0)
 312         throw new IllegalStateException("cannot change buffer size, because content was already written!");
 313       bufferSize = size;
 314       buffer = new byte[size];
 315     }
 316
 317     @Override
 318     public void resetBuffer() {
 319       if (committed)
 320         throw new IllegalStateException("cannot reset buffer, because response is already commited!");
 321       pos = 0;
 322       stream = null;
 323       writer = null;
 324     }
 325
 326     @Override
 327     public void reset() {
 328       if (committed)
 329         throw new IllegalStateException("cannot reset response, because response is already commited!");
 330       /**
 331        * Da committed==false gilt, wurde die Dekoration noch nicht angestßen
 332        * und muss entsprechend auch nicht rückgängig gemacht werden!
 333        */
 334       response.reset();
 335       pos = 0;
 336       stream = null;
 337       writer = null;
 338     }
 339
 340     @Override
 341     public void flushBuffer() throws IOException {
 342       if (writer != null)
 343         writer.flush();
 344       else if (stream != null)
 345         stream.flush();
 346
 347       out.flush();
 348     }
 349
 350     @Override
 351     public void addCookie(Cookie cookie) {
 352       // TODO: Je nach Vary-Einstellung ETag anpassen?
 353       response.addCookie(cookie);
 354     }
 355
 356     @Override
 357     public boolean containsHeader(String name) {
 358       return response.containsHeader(name);
 359     }
 360
 361     @Override
 362     public String encodeURL(String url) {
 363       return response.encodeURL(url);
 364     }
 365
 366     @Override
 367     public String encodeRedirectURL(String url) {
 368       return response.encodeRedirectURL(url);
 369     }
 370
 371     @Override
 372     public String encodeUrl(String url) {
 373       return response.encodeUrl(url);
 374     }
 375
 376     @Override
 377     public String encodeRedirectUrl(String url) {
 378       return response.encodeRedirectUrl(url);
 379     }
 380
 381     @Override
 382     public void sendError(int sc, String msg) throws IOException {
 383       response.sendError(sc,msg);
 384     }
 385
 386     @Override
 387     public void sendError(int sc) throws IOException {
 388       response.sendError(sc);
 389     }
 390
 391     @Override
 392     public void sendRedirect(String location) throws IOException {
 393       response.sendRedirect(location);
 394     }
 395
 396     @Override
 397     public String getCharacterEncoding() {
 398       return response.getCharacterEncoding();
 399     }
 400
 401     @Override
 402     public String getContentType() {
 403       return response.getContentType();
 404     }
 405
 406     @Override
 407     public void setCharacterEncoding(String charset) {
 408       // TODO: Je nach Vary-Einstellung ETag anpassen?
 409       response.setCharacterEncoding(charset);
 410     }
 411
 412     @Override
 413     public void setContentType(String type) {
 414       // TODO: Je nach Vary-Einstellung ETag anpassen?
 415       response.setContentType(type);
 416     }
 417
 418     @Override
 419     public boolean isCommitted() {
 420       return committed;
 421     }
 422
 423     @Override
 424     public void setLocale(Locale loc) {
 425       // TODO: Je nach Vary-Einstellung ETag anpassen?
 426       response.setLocale(loc);
 427     }
 428
 429     @Override
 430     public Locale getLocale() {
 431       return getLocale();
 432     }
 433
 434
 435
 436     @Override
 437     public boolean isZipped() {
 438       return zipped;
 439     }
 440
 441     @Override
 442     public long getTimestamp() {
 443       return now;
 444     }
 445
 446     @Override
 447     public int accepts(HttpServletRequest request) {
 448       return status;
 449     }
 450
 451     @Override
 452     public int getCacheSeconds(HttpServletRequest request) {
 453       return cacheSeconds;
 454     }
 455
 456     @Override
 457     public long getLastModified(HttpServletRequest request) {
 458       return lastModified;
 459     }
 460
 461     @Override
 462     public String getETag(HttpServletRequest request) {
 463       return eTag;
 464     }
 465
 466     @Override
 467     public boolean isETagWeak() {
 468       return weak;
 469     }
 470
 471     @Override
 472     public void cacheControl(HttpServletRequest request, Map<String, String> cacheControlMap) {
 473       cacheControlMap.putAll(cacheParams);
 474     }
 475
 476     @Override
 477     public Map<String,String> getAdditionalHeaders(HttpServletRequest request) {
 478       return EMPTY;
 479     }
 480
 481     public void supressGuessing() {
 482       guessing = false;
 483     }
 484
 485
 486     private void analyzeHeader(String name, String value, boolean overwrite) {
 487       if (name == null)
 488         return;
 489       name = name.trim();
 490
 491       if (name.equalsIgnoreCase(Headers.HEADER_DATE)) {
 492         if (value == null) {
 493           if (overwrite) {
 494             now = System.currentTimeMillis();
 495             cacheSeconds = AcceleratorFilter.this.cacheSeconds;
 496           }
 497           return;
 498         }
 499         try {
 500           SimpleDateFormat parser = new SimpleDateFormat(Headers.RFC_1123_DATE_FORMAT, Locale.US);
 501           now = parser.parse(value).getTime();
 502           calculateCacheSeconds();
 503         }
 504         catch (ParseException e) {
 505           log.warn("ignoring date for header \"Date\" in invalid format: {}", value);
 506         }
 507         return;
 508       }
 509
 510       if (name.equalsIgnoreCase(Headers.HEADER_EXPIRES)) {
 511         if (value == null) {
 512           if (overwrite) {
 513             expires = 0;
 514             cacheSeconds = AcceleratorFilter.this.cacheSeconds;
 515           }
 516           return;
 517         }
 518         try {
 519           SimpleDateFormat parser = new SimpleDateFormat(Headers.RFC_1123_DATE_FORMAT, Locale.US);
 520           expires = parser.parse(value).getTime();
 521           calculateCacheSeconds();
 522         }
 523         catch (ParseException e) {
 524           log.warn("ignoring date for header \"Expires\" in invalid format: {}", value);
 525         }
 526         return;
 527       }
 528
 529       if (name.equalsIgnoreCase(Headers.HEADER_LAST_MODIFIED)) {
 530         if (value == null) {
 531           if (overwrite)
 532             lastModified = AcceleratorFilter.this.lastModified;
 533           return;
 534         }
 535         try {
 536           SimpleDateFormat parser = new SimpleDateFormat(Headers.RFC_1123_DATE_FORMAT, Locale.US);
 537           lastModified = parser.parse(value).getTime();
 538         }
 539         catch (ParseException e) {
 540           log.warn("ignoring date for header \"Last-Modified\" in invalid format: {}", value);
 541         }
 542         return;
 543       }
 544
 545       if (name.equalsIgnoreCase(Headers.HEADER_ETAG)) {
 546         if (value == null) {
 547           if (overwrite) {
 548             eTag = AcceleratorFilter.this.eTag;
 549             weak = AcceleratorFilter.this.weak;
 550           }
 551           return;
 552         }
 553         value = value.trim();
 554         int start = 0;
 555         int end = value.length();
 556         if (value.startsWith("W/")) {
 557           weak = true;
 558           start = 2;
 559         }
 560         else {
 561           weak = false;
 562         }
 563         if (value.charAt(start) == '"')
 564           start++;
 565         else
 566           log.warn("Quote at the beginning ov ETag is missing: {}", value);
 567         if (value.charAt(end -1) == '"')
 568           end--;
 569         else
 570           log.warn("Quote at the end of ETag is missing: {}", value);
 571         eTag = value.substring(start, end);
 572         String filtered = eTag.replaceAll("[^\\x00-\\x21\\x23-\\x7F]+","");
 573         if (filtered.length() < eTag.length()) {
 574           log.warn("filtering out illegal characters in ETag: \"{}\" -> \"{}\"", eTag, filtered);
 575           eTag = filtered;
 576         }
 577       }
 578
 579       if (name.equalsIgnoreCase(Headers.HEADER_CACHE_CONTROL)) {
 580         if (overwrite)
 581           cacheParams.clear();
 582         if (value == null)
 583           return;
 584         for (String param : value.split(",")) {
 585           param = param.trim();
 586           int pos = param.indexOf("=");
 587           if (pos < 0) {
 588             cacheParams.put(param, null);
 589           }
 590           else {
 591             String paramName = param.substring(0, pos).trim();
 592             if (paramName.equalsIgnoreCase("max-age")) {
 593               try {
 594                 cacheSeconds = Integer.parseInt(param.substring(pos + 1));
 595                 cacheSecondsSet = true;
 596               }
 597               catch (NumberFormatException e) {
 598                 log.warn("illegal value for Header \"Cache-Control\":", param);
 599               }
 600             }
 601             else {
 602               cacheParams.put(paramName, param.substring(pos + 1));
 603             }
 604           }
 605         }
 606         return;
 607       }
 608
 609       if (name.equalsIgnoreCase(Headers.HEADER_PRAGMA)) {
 610         if (value != null && value.trim().equalsIgnoreCase("no-cache"))
 611           cacheSeconds = 0;
 612         return;
 613       }
 614
 615       /** Pass header through, if no value from intrest was found */
 616       if (overwrite)
 617         response.setHeader(name, value);
 618       else
 619         response.addHeader(name, value);
 620     }
 621
 622     private void calculateCacheSeconds() {
 623       if (!cacheSecondsSet && expires >= now) {
 624         cacheSeconds = (int)(expires/1000 - now/1000);
 625         log.debug("calculating cache-seconds from DATE and EXPIRES: {}", cacheSeconds);
 626       }
 627     }
 628
 629
 630     private class AcceleratorServletOutputStream extends ServletOutputStream  {
 631
 632       private final ServletOutputStream sos;
 633
 634
 635       private AcceleratorServletOutputStream() throws IOException {
 636         bufferSize = defaultBufferSize;
 637         buffer = new byte[bufferSize];
 638         sos = AccelerationWrapper.this.response.getOutputStream();
 639       }
 640
 641
 642       private OutputStream out() throws IOException {
 643         if (os == null)
 644           os = zipped ? new GZIPOutputStream(sos) : sos;
 645         return os;
 646       }
 647
 648       @Override
 649       public void write(int i) throws IOException {
 650         if (pos == bufferSize) {
 651           out().write(buffer);
 652           pos = 0;
 653           committed = true;
 654           cacheControl.decorate(request, response);
 655         }
 656         buffer[pos++] = (byte) i;
 657         size++;
 658       }
 659
 660       @Override
 661       public void flush() throws IOException {
 662         if (pos == 0)
 663           return;
 664
 665         committed = true;
 666         cacheControl.decorate(request, response);
 667         out().write(buffer, 0, pos);
 668         out().flush();
 669         pos = 0;
 670       }
 671
 672       @Override
 673       public void close() throws IOException {
 674         if (size == 0) {
 675           committed = true;
 676           zipped = false;
 677           cacheControl.decorate(request, response);
 678           sos.close();
 679         }
 680         else {
 681           flush();
 682           out().close();
 683         }
 684       }
 685     }
 686   }
 687 }