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       size = 0;
 337       stream = null;
 338       writer = null;
 339     }
 340
 341     @Override
 342     public void flushBuffer() throws IOException {
 343       if (writer != null)
 344         writer.flush();
 345       else if (stream != null)
 346         stream.flush();
 347
 348       out.flush();
 349     }
 350
 351     @Override
 352     public void addCookie(Cookie cookie) {
 353       // TODO: Je nach Vary-Einstellung ETag anpassen?
 354       response.addCookie(cookie);
 355     }
 356
 357     @Override
 358     public boolean containsHeader(String name) {
 359       return response.containsHeader(name);
 360     }
 361
 362     @Override
 363     public String encodeURL(String url) {
 364       return response.encodeURL(url);
 365     }
 366
 367     @Override
 368     public String encodeRedirectURL(String url) {
 369       return response.encodeRedirectURL(url);
 370     }
 371
 372     @Override
 373     public String encodeUrl(String url) {
 374       return response.encodeUrl(url);
 375     }
 376
 377     @Override
 378     public String encodeRedirectUrl(String url) {
 379       return response.encodeRedirectUrl(url);
 380     }
 381
 382     @Override
 383     public void sendError(int sc, String msg) throws IOException {
 384       response.sendError(sc,msg);
 385     }
 386
 387     @Override
 388     public void sendError(int sc) throws IOException {
 389       response.sendError(sc);
 390     }
 391
 392     @Override
 393     public void sendRedirect(String location) throws IOException {
 394       response.sendRedirect(location);
 395     }
 396
 397     @Override
 398     public String getCharacterEncoding() {
 399       return response.getCharacterEncoding();
 400     }
 401
 402     @Override
 403     public String getContentType() {
 404       return response.getContentType();
 405     }
 406
 407     @Override
 408     public void setCharacterEncoding(String charset) {
 409       // TODO: Je nach Vary-Einstellung ETag anpassen?
 410       response.setCharacterEncoding(charset);
 411     }
 412
 413     @Override
 414     public void setContentType(String type) {
 415       // TODO: Je nach Vary-Einstellung ETag anpassen?
 416       response.setContentType(type);
 417     }
 418
 419     @Override
 420     public boolean isCommitted() {
 421       return committed;
 422     }
 423
 424     @Override
 425     public void setLocale(Locale loc) {
 426       // TODO: Je nach Vary-Einstellung ETag anpassen?
 427       response.setLocale(loc);
 428     }
 429
 430     @Override
 431     public Locale getLocale() {
 432       return getLocale();
 433     }
 434
 435
 436
 437     @Override
 438     public boolean isZipped() {
 439       return zipped;
 440     }
 441
 442     @Override
 443     public long getTimestamp() {
 444       return now;
 445     }
 446
 447     @Override
 448     public int accepts(HttpServletRequest request) {
 449       return status;
 450     }
 451
 452     @Override
 453     public int getCacheSeconds(HttpServletRequest request) {
 454       return cacheSeconds;
 455     }
 456
 457     @Override
 458     public long getLastModified(HttpServletRequest request) {
 459       return lastModified;
 460     }
 461
 462     @Override
 463     public String getETag(HttpServletRequest request) {
 464       return eTag;
 465     }
 466
 467     @Override
 468     public boolean isETagWeak() {
 469       return weak;
 470     }
 471
 472     @Override
 473     public void cacheControl(HttpServletRequest request, Map<String, String> cacheControlMap) {
 474       cacheControlMap.putAll(cacheParams);
 475     }
 476
 477     @Override
 478     public Map<String,String> getAdditionalHeaders(HttpServletRequest request) {
 479       return EMPTY;
 480     }
 481
 482     public void supressGuessing() {
 483       guessing = false;
 484     }
 485
 486
 487     private void analyzeHeader(String name, String value, boolean overwrite) {
 488       if (name == null)
 489         return;
 490       name = name.trim();
 491
 492       if (name.equalsIgnoreCase(Headers.HEADER_DATE)) {
 493         if (value == null) {
 494           if (overwrite) {
 495             now = System.currentTimeMillis();
 496             cacheSeconds = AcceleratorFilter.this.cacheSeconds;
 497           }
 498           return;
 499         }
 500         try {
 501           SimpleDateFormat parser = new SimpleDateFormat(Headers.RFC_1123_DATE_FORMAT, Locale.US);
 502           now = parser.parse(value).getTime();
 503           calculateCacheSeconds();
 504         }
 505         catch (ParseException e) {
 506           log.warn("ignoring date for header \"Date\" in invalid format: {}", value);
 507         }
 508         return;
 509       }
 510
 511       if (name.equalsIgnoreCase(Headers.HEADER_EXPIRES)) {
 512         if (value == null) {
 513           if (overwrite) {
 514             expires = 0;
 515             cacheSeconds = AcceleratorFilter.this.cacheSeconds;
 516           }
 517           return;
 518         }
 519         try {
 520           SimpleDateFormat parser = new SimpleDateFormat(Headers.RFC_1123_DATE_FORMAT, Locale.US);
 521           expires = parser.parse(value).getTime();
 522           calculateCacheSeconds();
 523         }
 524         catch (ParseException e) {
 525           log.warn("ignoring date for header \"Expires\" in invalid format: {}", value);
 526         }
 527         return;
 528       }
 529
 530       if (name.equalsIgnoreCase(Headers.HEADER_LAST_MODIFIED)) {
 531         if (value == null) {
 532           if (overwrite)
 533             lastModified = AcceleratorFilter.this.lastModified;
 534           return;
 535         }
 536         try {
 537           SimpleDateFormat parser = new SimpleDateFormat(Headers.RFC_1123_DATE_FORMAT, Locale.US);
 538           lastModified = parser.parse(value).getTime();
 539         }
 540         catch (ParseException e) {
 541           log.warn("ignoring date for header \"Last-Modified\" in invalid format: {}", value);
 542         }
 543         return;
 544       }
 545
 546       if (name.equalsIgnoreCase(Headers.HEADER_ETAG)) {
 547         if (value == null) {
 548           if (overwrite) {
 549             eTag = AcceleratorFilter.this.eTag;
 550             weak = AcceleratorFilter.this.weak;
 551           }
 552           return;
 553         }
 554         value = value.trim();
 555         int start = 0;
 556         int end = value.length();
 557         if (value.startsWith("W/")) {
 558           weak = true;
 559           start = 2;
 560         }
 561         else {
 562           weak = false;
 563         }
 564         if (value.charAt(start) == '"')
 565           start++;
 566         else
 567           log.warn("Quote at the beginning ov ETag is missing: {}", value);
 568         if (value.charAt(end -1) == '"')
 569           end--;
 570         else
 571           log.warn("Quote at the end of ETag is missing: {}", value);
 572         eTag = value.substring(start, end);
 573         String filtered = eTag.replaceAll("[^\\x00-\\x21\\x23-\\x7F]+","");
 574         if (filtered.length() < eTag.length()) {
 575           log.warn("filtering out illegal characters in ETag: \"{}\" -> \"{}\"", eTag, filtered);
 576           eTag = filtered;
 577         }
 578       }
 579
 580       if (name.equalsIgnoreCase(Headers.HEADER_CACHE_CONTROL)) {
 581         if (overwrite)
 582           cacheParams.clear();
 583         if (value == null)
 584           return;
 585         for (String param : value.split(",")) {
 586           param = param.trim();
 587           int pos = param.indexOf("=");
 588           if (pos < 0) {
 589             cacheParams.put(param, null);
 590           }
 591           else {
 592             String paramName = param.substring(0, pos).trim();
 593             if (paramName.equalsIgnoreCase("max-age")) {
 594               try {
 595                 cacheSeconds = Integer.parseInt(param.substring(pos + 1));
 596                 cacheSecondsSet = true;
 597               }
 598               catch (NumberFormatException e) {
 599                 log.warn("illegal value for Header \"Cache-Control\":", param);
 600               }
 601             }
 602             else {
 603               cacheParams.put(paramName, param.substring(pos + 1));
 604             }
 605           }
 606         }
 607         return;
 608       }
 609
 610       if (name.equalsIgnoreCase(Headers.HEADER_PRAGMA)) {
 611         if (value != null && value.trim().equalsIgnoreCase("no-cache"))
 612           cacheSeconds = 0;
 613         return;
 614       }
 615
 616       /** Pass header through, if no value from intrest was found */
 617       if (overwrite)
 618         response.setHeader(name, value);
 619       else
 620         response.addHeader(name, value);
 621     }
 622
 623     private void calculateCacheSeconds() {
 624       if (!cacheSecondsSet && expires >= now) {
 625         cacheSeconds = (int)(expires/1000 - now/1000);
 626         log.debug("calculating cache-seconds from DATE and EXPIRES: {}", cacheSeconds);
 627       }
 628     }
 629
 630
 631     private class AcceleratorServletOutputStream extends ServletOutputStream  {
 632
 633       private final ServletOutputStream sos;
 634
 635
 636       private AcceleratorServletOutputStream() throws IOException {
 637         bufferSize = defaultBufferSize;
 638         buffer = new byte[bufferSize];
 639         sos = AccelerationWrapper.this.response.getOutputStream();
 640       }
 641
 642
 643       private OutputStream out() throws IOException {
 644         if (os == null)
 645           os = zipped ? new GZIPOutputStream(sos) : sos;
 646         return os;
 647       }
 648
 649       @Override
 650       public void write(int i) throws IOException {
 651         if (pos == bufferSize) {
 652           out().write(buffer);
 653           committed = true;
 654           /** Dekoration nur beim ersten Schreib-Schub anstoßen */
 655           if (pos == size)
 656             cacheControl.decorate(request, response);
 657           pos = 0;
 658         }
 659         buffer[pos++] = (byte) i;
 660         size++;
 661       }
 662
 663       @Override
 664       public void flush() throws IOException {
 665         if (pos == 0)
 666           return;
 667
 668         committed = true;
 669         /** Dekoration nur beim ersten Schreib-Schub anstoßen */
 670         if (pos == size)
 671           cacheControl.decorate(request, response);
 672         out().write(buffer, 0, pos);
 673         out().flush();
 674         pos = 0;
 675       }
 676
 677       @Override
 678       public void close() throws IOException {
 679         if (size == 0) {
 680           committed = true;
 681           zipped = false;
 682           cacheControl.decorate(request, response);
 683           sos.close();
 684         }
 685         else {
 686           flush();
 687           out().close();
 688         }
 689       }
 690     }
 691   }
 692 }