package de.halbekunst.juplo.cachecontrol;
-import de.halbekunst.juplo.cachecontrol.CacheControl.CacheMethodHandle;
+import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintWriter;
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;
+ 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";
- 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;
@Autowired(required=true) Integer buffer;
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;
- private int buffer;
- private GZIPServletOutputStream out;
+ boolean zipped; // CacheControll greift direkt auf dieses Flag zu!
+ boolean forceCompression = false;
+
+ private CountingServletOutputStream out;
private ServletOutputStream stream;
private PrintWriter writer;
weak = AcceleratorFilter.this.weak;
cacheParams = new HashMap<String,String>();
- buffer = AcceleratorFilter.this.buffer;
zipped = false;
Enumeration values = request.getHeaders(Headers.HEADER_ACCEPT_ENCODING);
while (values.hasMoreElements()) {
break;
}
}
+ if (zipped)
+ out = new GZIPServletOutputStream();
+ else
+ out = new CountingServletOutputStream();
}
-
public void finish() throws IOException {
- if (zipped && out != null)
- out.zout.finish();
+ out.close();
}
throw new IllegalStateException("ServletOutputStream and PrintWriter cannot be requested both!");
if (stream == null) {
- out = new GZIPServletOutputStream();
stream = out;
}
throw new IllegalStateException("ServletOutputStream and PrintWriter cannot be requested both!");
if (writer == null) {
- out = new GZIPServletOutputStream();
writer = new PrintWriter(out);
}
@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;
+ out.setBuffer(size);
response.setBufferSize(size);
}
@Override
public void flushBuffer() throws IOException {
+ forceCompression = true;
cacheControl.decorate(request, response, this);
response.flushBuffer();
}
public void resetBuffer() {
response.resetBuffer();
+ try {
+ if (zipped)
+ out = new GZIPServletOutputStream();
+ else
+ out = new CountingServletOutputStream();
+ }
+ catch (IOException e) {
+ throw new IllegalStateException(e);
+ }
stream = null;
writer = null;
}
public void reset() {
response.reset();
- out = null;
+ try {
+ if (zipped)
+ out = new GZIPServletOutputStream();
+ else
+ out = new CountingServletOutputStream();
+ }
+ catch (IOException e) {
+ throw new IllegalStateException(e);
+ }
stream = null;
writer = null;
/** Cookies has been cleared! Reinitialize decorator... */
+ forceCompression = false;
cacheControl.init(this);
}
+ @Override
+ public boolean isZipped() {
+ return out.isZipped();
+ }
+
@Override
public long getTimestamp() {
return now;
@Override
public Map<String,String> getAdditionalHeaders(HttpServletRequest request) {
- if (zipped && !out.empty)
- return ADDITIONAL_HEADERS_GZIP;
- else
- return ADDITIONAL_HEADERS_NONE;
+ return EMPTY;
}
- public void guessingFinished() {
+ public void supressGuessing() {
guessing = false;
}
}
- class GZIPServletOutputStream extends ServletOutputStream {
+ class CountingServletOutputStream extends ServletOutputStream {
- private final OutputStream out;
- private final GZIPOutputStream zout;
+ private OutputStream out;
int left;
boolean empty;
- public GZIPServletOutputStream() throws IOException {
- if (zipped) {
- this.zout = new GZIPOutputStream(response.getOutputStream(), buffer);
- this.out = this.zout;
- }
- else {
- this.zout = null;
- this.out = response.getOutputStream();
- }
- empty = true;
+
+ CountingServletOutputStream() throws IOException {
+ out = response.getOutputStream();
left = buffer;
+ empty = true;
}
- @Override
- public void close() throws IOException {
+ void setBuffer(int size) throws IllegalStateException {}
+
+ boolean isZipped() {
+ return false;
+ }
+
+ void finish() throws IOException {
+ decorate();
+ }
+
+ void decorate() throws IOException {
try {
- AcceleratorFilter.this.cacheControl.decorate(AccelerationWrapper.this.request, response, buffer);
+ AcceleratorFilter.this.cacheControl.decorate(AccelerationWrapper.this.request, response, AccelerationWrapper.this);
}
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();
+
+ @Override
+ public void close() throws IOException {
+ decorate();
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);
- }
-
+ decorate();
out.flush();
}
@Override
public void write(int i) throws IOException {
- if (left == 0) {
+ empty = false;
+ if (left == 0)
+ decorate();
+ left--;
+ out.write(i);
+ }
+ }
+
+
+ final class GZIPServletOutputStream extends CountingServletOutputStream {
+
+ final static int MINIMAL_BUFFER_SIZE = 128;
+
+ private ByteArrayOutputStream buffer;
+ private OutputStream out;
+ private GZIPOutputStream zout;
+ private int bufferSize;
+ private boolean decorated = false;
+
+
+ public GZIPServletOutputStream() throws IOException {
+ setBuffer(AcceleratorFilter.this.buffer);
+ }
+
+
+ @Override
+ void finish() throws IOException {
+ decorate();
+ zout.finish();
+ super.out.write(buffer.toByteArray());
+ }
+
+ @Override
+ boolean isZipped() {
+ if (decorated)
+ return true;
+ return !empty;
+ }
+
+ @Override
+ void setBuffer(int size) throws IllegalStateException {
+ if (!empty)
+ throw new IllegalStateException("attemp to change buffer size after writing data to response!");
+
+ if (size > MINIMAL_BUFFER_SIZE) {
+ left = size;
try {
- AcceleratorFilter.this.cacheControl.decorate(AccelerationWrapper.this.request, response, buffer);
+ bufferSize = size;
+ out = response.getOutputStream();
+ buffer = new ByteArrayOutputStream(size);
+ zout = new GZIPOutputStream(buffer, size);
+ super.out = zout;
}
- catch (Exception e) {
- log.error("Error while guessing Cache-Header's", e);
- response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
+ catch (IOException e) {
+ throw new IllegalStateException(e);
}
}
+ }
+
+
+
+ @Override
+ public void close() throws IOException {
+ decorate();
+ zout.close();
+ out.write(buffer.toByteArray());
+ out.close();
+ }
+
+ @Override
+ public void flush() throws IOException {
+ decorate();
+ out.write(buffer.toByteArray());
+ out.flush();
+ }
+
+ @Override
+ public void write(int i) throws IOException {
empty = false;
+ if (left == 0) {
+ if (!decorated) {
+ decorate();
+ decorated = true;
+ }
+ out.write(buffer.toByteArray());
+ buffer.reset();
+ left = bufferSize;
+ }
left--;
- out.write(i);
+ zout.write(i);
}
}
}
projects / percentcodec / blobdiff