X-Git-Url: https://juplo.de/gitweb/?p=percentcodec;a=blobdiff_plain;f=cachecontrol%2Fsrc%2Fmain%2Fjava%2Fde%2Fhalbekunst%2Fjuplo%2Fcachecontrol%2FAcceleratorFilter.java;h=f76c7132cfd1c3b0de341011d23e2d3bf8b0c1d2;hp=82c40822950093f19c50b8989dd5b66b0995e686;hb=1bb1a0f0e1d347538ae93c23395bba172cd87342;hpb=3324545626f8f93c43e3b54cf56004d19af17da2

diff --git a/cachecontrol/src/main/java/de/halbekunst/juplo/cachecontrol/AcceleratorFilter.java b/cachecontrol/src/main/java/de/halbekunst/juplo/cachecontrol/AcceleratorFilter.java
index 82c40822..f76c7132 100644
--- a/cachecontrol/src/main/java/de/halbekunst/juplo/cachecontrol/AcceleratorFilter.java
+++ b/cachecontrol/src/main/java/de/halbekunst/juplo/cachecontrol/AcceleratorFilter.java
@@ -4,7 +4,12 @@ import de.halbekunst.juplo.cachecontrol.CacheControl.CacheMethodHandle;
 import java.io.IOException;
 import java.io.OutputStream;
 import java.io.PrintWriter;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Collections;
 import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Locale;
 import java.util.Map;
 import java.util.zip.GZIPOutputStream;
 import javax.servlet.Filter;
@@ -19,6 +24,7 @@ import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpServletResponseWrapper;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowire;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Configurable;
 
@@ -28,11 +34,21 @@ import org.springframework.beans.factory.annotation.Configurable;
  *
  * @author kai
  */
-@Configurable
+@Configurable(autowire=Autowire.BY_NAME)
 public class AcceleratorFilter implements Filter {
   private final static Logger log = LoggerFactory.getLogger(AcceleratorFilter.class);
 
+  private final static Map<String,String> ADDITIONAL_HEADERS_NONE = Collections.unmodifiableMap(new HashMap<String,String>());
+  private final static Map<String,String> ADDITIONAL_HEADERS_GZIP;
+
   public final static String REQUEST_URI_ATTRIBUTE = "javax.servlet.include.request_uri";
+  public final static String RESPONSE_WRAPPER = AcceleratorFilter.class.getName() + ".RESPONSE_WRAPPER";
+
+  static {
+    Map<String,String> map = new HashMap<String,String>(1);
+    map.put(Headers.HEADER_CONTENT_ENCODING, "gzip");
+    ADDITIONAL_HEADERS_GZIP = Collections.unmodifiableMap(map);
+  }
 
 
   @Autowired CacheControl cacheControl;
@@ -58,9 +74,14 @@ public class AcceleratorFilter implements Filter {
       return;
     }
 
-    AccelerationWrapper wrapper = new AccelerationWrapper((HttpServletRequest)request, (HttpServletResponse)response);
+    HttpServletRequest httpRequest = (HttpServletRequest)request;
+    HttpServletResponse httpResponse = (HttpServletResponse)response;
+    AccelerationWrapper wrapper = new AccelerationWrapper(httpRequest, httpResponse);
+    httpRequest.setAttribute(RESPONSE_WRAPPER, wrapper);
     cacheControl.init(wrapper);
     chain.doFilter(request, wrapper);
+    /** Dekoration auslösen, falls sie bisher nicht ausgelöst wurde... */
+    cacheControl.decorate(httpRequest, httpResponse, wrapper);
     wrapper.finish();
   }
 
@@ -79,12 +100,21 @@ public class AcceleratorFilter implements Filter {
     private final HttpServletResponse response;
 
     private boolean zipped;
+    private int buffer;
     private GZIPServletOutputStream out;
+    private ServletOutputStream stream;
+    private PrintWriter writer;
+
+    private boolean guessing = true;
 
     private long now;
-    private int buffer;
     private int status;
-    private String type;
+    private int cacheSeconds;
+    private boolean cacheSecondsSet = false;
+    private long lastModified, expires = 0l;
+    private String eTag;
+    private boolean weak;
+    private Map<String,String> cacheParams;
 
 
     AccelerationWrapper(HttpServletRequest request, HttpServletResponse response) throws IOException {
@@ -94,16 +124,20 @@ public class AcceleratorFilter implements Filter {
       this.response = response;
 
       now = System.currentTimeMillis();
-      buffer = AcceleratorFilter.this.buffer;
       status = HttpServletResponse.SC_OK;
+      cacheSeconds = AcceleratorFilter.this.cacheSeconds;
+      lastModified = AcceleratorFilter.this.lastModified;
+      eTag = AcceleratorFilter.this.eTag;
+      weak = AcceleratorFilter.this.weak;
+      cacheParams = new HashMap<String,String>();
 
+      buffer = AcceleratorFilter.this.buffer;
       zipped = false;
-      Enumeration values = request.getHeaders(HeaderNames.HEADER_ACCEPT_ENCODING);
+      Enumeration values = request.getHeaders(Headers.HEADER_ACCEPT_ENCODING);
       while (values.hasMoreElements()) {
         String value = (String) values.nextElement();
         if (value.indexOf("gzip") != -1) {
           zipped = true;
-          response.addHeader(HeaderNames.HEADER_CONTENT_ENCODING, "gzip");
           break;
         }
       }
@@ -140,57 +174,186 @@ public class AcceleratorFilter implements Filter {
       }
     }
 
+    @Override
+    public void addDateHeader(String name, long value) {
+
+      if (!guessing) {
+        super.addDateHeader(name, value);
+        return;
+      }
+
+      if (Headers.HEADER_DATE.equalsIgnoreCase(name)) {
+        now = value;
+        calculateCacheSeconds();
+        return;
+      }
+
+      if (Headers.HEADER_EXPIRES.equalsIgnoreCase(name)) {
+        expires = value;
+        calculateCacheSeconds();
+        return;
+      }
+
+      if (Headers.HEADER_LAST_MODIFIED.equalsIgnoreCase(name)) {
+        lastModified = value;
+        return;
+      }
+
+      /** Unknown header: pass throug! */
+      super.addDateHeader(name, value);
+    }
+
+    @Override
+    public void addHeader(String name, String value) {
+
+      if (!guessing) {
+        super.addHeader(name, value);
+        return;
+      }
+
+      if (value == null)
+        return;
+      analyzeHeader(name, value, false);
+    }
+
+    @Override
+    public void addIntHeader(String name, int value) {
+
+      if (!guessing) {
+        super.addIntHeader(name, value);
+        return;
+      }
+
+      analyzeHeader(name, Integer.toString(value), false);
+    }
+
+    @Override
+    public void setDateHeader(String name, long value) {
+
+      if (!guessing) {
+        super.setDateHeader(name, value);
+        return;
+      }
+
+      if (Headers.HEADER_DATE.equalsIgnoreCase(name)) {
+        now = value;
+        calculateCacheSeconds();
+        return;
+      }
+
+      if (Headers.HEADER_EXPIRES.equalsIgnoreCase(name)) {
+        expires = value;
+        calculateCacheSeconds();
+        return;
+      }
+
+      if (Headers.HEADER_LAST_MODIFIED.equalsIgnoreCase(name)) {
+        lastModified = value;
+        return;
+      }
+
+      /** Unknown header: pass throug! */
+      super.setDateHeader(name, value);
+    }
+
+    @Override
+    public void setHeader(String name, String value) {
+
+      if (!guessing) {
+        super.setHeader(name, value);
+        return;
+      }
+
+      analyzeHeader(name, value, true);
+    }
+
+    @Override
+    public void setIntHeader(String name, int value) {
+
+      if (!guessing) {
+        super.setIntHeader(name, value);
+        return;
+      }
+
+      analyzeHeader(name, Integer.toString(value), true);
+    }
+
     @Override
     public ServletOutputStream getOutputStream() throws IOException {
-      if (out == null)
-        out = new GZIPServletOutputStream(response.getOutputStream(), zipped);
+
+      if (writer != null)
+        throw new IllegalStateException("ServletOutputStream and PrintWriter cannot be requested both!");
+
+      if (stream == null) {
+        out = new GZIPServletOutputStream();
+        stream = out;
+      }
+
       return out;
     }
 
     @Override
     public PrintWriter getWriter() throws IOException {
-      return new PrintWriter(getOutputStream());
+
+      if (stream != null)
+        throw new IllegalStateException("ServletOutputStream and PrintWriter cannot be requested both!");
+
+      if (writer == null) {
+        out = new GZIPServletOutputStream();
+        writer = new PrintWriter(out);
+      }
+
+      return writer;
     }
 
     @Override
-    public void setContentType(String type) {
-      this.type = type;
-      response.setContentType(type);
+    public void setContentLength(int len) {
+      if (zipped)
+        log.info("Supressing explicit content-length {} for request {}, because content will be zipped!", len, request.getRequestURI());
+      else
+        response.setContentLength(len);
     }
 
     @Override
     public void setBufferSize(int size) {
+
+      if (out != null && this.buffer != out.left)
+        throw new IllegalStateException("setBufferSize() cannot be called after content has been written!");
+
+      if (size < 0)
+        size = 0;
+
       this.buffer = size;
+      if (out != null)
+        out.left = size;
       response.setBufferSize(size);
     }
 
-    @Override
-    public int getBufferSize() {
-      return buffer;
-    }
-
     @Override
     public void flushBuffer() throws IOException {
+
       cacheControl.decorate(request, response, this);
-      if (zipped && out != null) {
-        out.zout.finish();
-      }
       response.flushBuffer();
     }
 
     @Override
     public void resetBuffer() {
-      response.resetBuffer();
-    }
 
-    @Override
-    public boolean isCommitted() {
-      return response.isCommitted();
+      response.resetBuffer();
+      stream = null;
+      writer = null;
     }
 
     @Override
     public void reset() {
+
       response.reset();
+      out = null;
+      stream = null;
+      writer = null;
+
+      /** Cookies has been cleared! Reinitialize decorator... */
+      cacheControl.init(this);
     }
 
 
@@ -227,6 +390,163 @@ public class AcceleratorFilter implements Filter {
 
     @Override
     public void cacheControl(HttpServletRequest request, Map<String, String> cacheControlMap) {
+      cacheControlMap.putAll(cacheParams);
+    }
+
+    @Override
+    public Map<String,String> getAdditionalHeaders(HttpServletRequest request) {
+      if (zipped && !out.empty)
+        return ADDITIONAL_HEADERS_GZIP;
+      else
+        return ADDITIONAL_HEADERS_NONE;
+    }
+
+    public void guessingFinished() {
+      guessing = false;
+    }
+
+
+    private void analyzeHeader(String name, String value, boolean overwrite) {
+      if (name == null)
+        return;
+      name = name.trim();
+
+      if (name.equalsIgnoreCase(Headers.HEADER_DATE)) {
+        if (value == null) {
+          if (overwrite) {
+            now = System.currentTimeMillis();
+            cacheSeconds = AcceleratorFilter.this.cacheSeconds;
+          }
+          return;
+        }
+        try {
+          SimpleDateFormat parser = new SimpleDateFormat(Headers.RFC_1123_DATE_FORMAT, Locale.US);
+          now = parser.parse(value).getTime();
+          calculateCacheSeconds();
+        }
+        catch (ParseException e) {
+          log.warn("ignoring date for header \"Date\" in invalid format: {}", value);
+        }
+        return;
+      }
+
+      if (name.equalsIgnoreCase(Headers.HEADER_EXPIRES)) {
+        if (value == null) {
+          if (overwrite) {
+            expires = 0;
+            cacheSeconds = AcceleratorFilter.this.cacheSeconds;
+          }
+          return;
+        }
+        try {
+          SimpleDateFormat parser = new SimpleDateFormat(Headers.RFC_1123_DATE_FORMAT, Locale.US);
+          expires = parser.parse(value).getTime();
+          calculateCacheSeconds();
+        }
+        catch (ParseException e) {
+          log.warn("ignoring date for header \"Expires\" in invalid format: {}", value);
+        }
+        return;
+      }
+
+      if (name.equalsIgnoreCase(Headers.HEADER_LAST_MODIFIED)) {
+        if (value == null) {
+          if (overwrite)
+            lastModified = AcceleratorFilter.this.lastModified;
+          return;
+        }
+        try {
+          SimpleDateFormat parser = new SimpleDateFormat(Headers.RFC_1123_DATE_FORMAT, Locale.US);
+          lastModified = parser.parse(value).getTime();
+        }
+        catch (ParseException e) {
+          log.warn("ignoring date for header \"Last-Modified\" in invalid format: {}", value);
+        }
+        return;
+      }
+
+      if (name.equalsIgnoreCase(Headers.HEADER_ETAG)) {
+        if (value == null) {
+          if (overwrite) {
+            eTag = AcceleratorFilter.this.eTag;
+            weak = AcceleratorFilter.this.weak;
+          }
+          return;
+        }
+        value = value.trim();
+        int start = 0;
+        int end = value.length();
+        if (value.startsWith("W/")) {
+          weak = true;
+          start = 2;
+        }
+        else {
+          weak = false;
+        }
+        if (value.charAt(start) == '"')
+          start++;
+        else
+          log.warn("Quote at the beginning ov ETag is missing: {}", value);
+        if (value.charAt(end -1) == '"')
+          end--;
+        else
+          log.warn("Quote at the end of ETag is missing: {}", value);
+        eTag = value.substring(start, end);
+        String filtered = eTag.replaceAll("[^\\x00-\\x21\\x23-\\x7F]+","");
+        if (filtered.length() < eTag.length()) {
+          log.warn("filtering out illegal characters in ETag: \"{}\" -> \"{}\"", eTag, filtered);
+          eTag = filtered;
+        }
+      }
+
+      if (name.equalsIgnoreCase(Headers.HEADER_CACHE_CONTROL)) {
+        if (overwrite)
+          cacheParams.clear();
+        if (value == null)
+          return;
+        for (String param : value.split(",")) {
+          param = param.trim();
+          int pos = param.indexOf("=");
+          if (pos < 0) {
+            cacheParams.put(param, null);
+          }
+          else {
+            String paramName = param.substring(0, pos).trim();
+            if (paramName.equalsIgnoreCase("max-age")) {
+              try {
+                cacheSeconds = Integer.parseInt(param.substring(pos + 1));
+                cacheSecondsSet = true;
+              }
+              catch (NumberFormatException e) {
+                log.warn("illegal value for Header \"Cache-Control\":", param);
+              }
+            }
+            else {
+              cacheParams.put(paramName, param.substring(pos + 1));
+            }
+          }
+        }
+        return;
+      }
+
+      if (name.equalsIgnoreCase(Headers.HEADER_PRAGMA)) {
+        if (value != null && value.trim().equalsIgnoreCase("no-cache"))
+          cacheSeconds = 0;
+        return;
+      }
+
+      /** Pass header through, if no value from intrest was found */
+      if (overwrite)
+        super.setHeader(name, value);
+      else
+        super.addHeader(name, value);
+    }
+
+    private void calculateCacheSeconds() {
+      if (!cacheSecondsSet && expires >= now) {
+        cacheSeconds = (int)(expires/1000 - now/1000);
+        log.debug("calculating cache-seconds from DATE and EXPIRES: {}", cacheSeconds);
+      }
     }
 
 
@@ -234,24 +554,54 @@ public class AcceleratorFilter implements Filter {
 
       private final OutputStream out;
       private final GZIPOutputStream zout;
-      private boolean untouched = true;
+      int left;
+      boolean empty;
 
-      public GZIPServletOutputStream(ServletOutputStream out, boolean zipped) throws IOException {
+      public GZIPServletOutputStream() throws IOException {
         if (zipped) {
-          this.zout = new GZIPOutputStream(out, buffer);
+          this.zout = new GZIPOutputStream(response.getOutputStream(), buffer);
           this.out = this.zout;
         }
         else {
-          this.out = out;
           this.zout = null;
+          this.out = response.getOutputStream();
+        }
+        empty = true;
+        left = buffer;
+      }
+
+
+      @Override
+      public void close() throws IOException {
+        try {
+          AcceleratorFilter.this.cacheControl.decorate(AccelerationWrapper.this.request, response, buffer);
+        }
+        catch (Exception e) {
+          log.error("Error while guessing Cache-Header's", e);
+          response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
         }
+
+        if (!empty && zout != null)
+          zout.finish();
+        out.close();
       }
 
+      @Override
+      public void flush() throws IOException {
+        try {
+          AcceleratorFilter.this.cacheControl.decorate(AccelerationWrapper.this.request, response, buffer);
+        }
+        catch (Exception e) {
+          log.error("Error while guessing Cache-Header's", e);
+          response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
+        }
+
+        out.flush();
+      }
 
       @Override
       public void write(int i) throws IOException {
-        if (untouched) {
-          untouched = false;
+        if (left == 0) {
           try {
             AcceleratorFilter.this.cacheControl.decorate(AccelerationWrapper.this.request, response, buffer);
           }
@@ -260,6 +610,8 @@ public class AcceleratorFilter implements Filter {
             response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
           }
         }
+        empty = false;
+        left--;
         out.write(i);
       }
     }