package de.halbekunst.juplo.cachecontrol;
-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;
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;
*
* @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> EMPTY = Collections.unmodifiableMap(new HashMap<String,String>());
+
public final static String REQUEST_URI_ATTRIBUTE = "javax.servlet.include.request_uri";
+ public final static String RESPONSE_WRAPPER = AcceleratorFilter.class.getName() + ".RESPONSE_WRAPPER";
@Autowired CacheControl cacheControl;
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();
}
private final HttpServletRequest request;
private final HttpServletResponse response;
- private boolean zipped;
+ boolean zipped; // CacheControll greift direkt auf dieses Flag zu!
+
+ 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 {
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;
}
}
}
}
+ @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);
}
+ @Override
+ public boolean isZipped() {
+ return zipped && out != null && !out.empty;
+ }
+
@Override
public long getTimestamp() {
return now;
@Override
public void cacheControl(HttpServletRequest request, Map<String, String> cacheControlMap) {
+ cacheControlMap.putAll(cacheParams);
+ }
+
+ @Override
+ public Map<String,String> getAdditionalHeaders(HttpServletRequest request) {
+ return EMPTY;
+ }
+
+ public void supressGuessing() {
+ 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);
+ }
}
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);
}
response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
}
}
+ empty = false;
+ left--;
out.write(i);
}
}
projects / percentcodec / blobdiff