From 9244292fcaeb0b688802f6e8d4c52527b5bad45f Mon Sep 17 00:00:00 2001 From: Greg Wilkins <gregw@webtide.com> Date: Mon, 2 Apr 2012 12:09:03 +1000 Subject: [PATCH] 375692: simplified gzipfilter --- .../AbstractCompressedResponseWrapper.java | 412 ------------------ .../http/gzip/AbstractCompressedStream.java | 22 +- .../http/gzip/CompressedResponseWrapper.java | 401 ++++++++++++++++- .../jetty/http/gzip/CompressedStream.java | 77 ---- .../jetty/http/gzip/CompressionType.java | 48 -- .../http/gzip/DeflateResponseWrapperImpl.java | 54 --- .../jetty/http/gzip/DeflateStreamImpl.java | 55 --- .../http/gzip/GzipResponseWrapperImpl.java | 53 --- .../jetty/http/gzip/GzipStreamImpl.java | 56 --- .../jetty/server/handler/GzipHandler.java | 24 +- .../eclipse/jetty/servlets/GzipFilter.java | 70 ++- .../jetty/servlets/IncludableGzipFilter.java | 138 +++--- .../servlets/GzipFilterContentLengthTest.java | 39 +- .../GzipFilterDefaultNoRecompressTest.java | 61 ++- .../jetty/servlets/GzipFilterDefaultTest.java | 23 +- .../servlets/GzipWithPipeliningTest.java | 13 +- .../IncludableGzipFilterMinSizeTest.java | 13 +- .../servlets/IncludableGzipFilterTest.java | 21 +- .../jetty/servlets/gzip/GzipTester.java | 19 +- 19 files changed, 618 insertions(+), 981 deletions(-) delete mode 100644 jetty-http/src/main/java/org/eclipse/jetty/http/gzip/AbstractCompressedResponseWrapper.java delete mode 100644 jetty-http/src/main/java/org/eclipse/jetty/http/gzip/CompressedStream.java delete mode 100644 jetty-http/src/main/java/org/eclipse/jetty/http/gzip/CompressionType.java delete mode 100644 jetty-http/src/main/java/org/eclipse/jetty/http/gzip/DeflateResponseWrapperImpl.java delete mode 100644 jetty-http/src/main/java/org/eclipse/jetty/http/gzip/DeflateStreamImpl.java delete mode 100644 jetty-http/src/main/java/org/eclipse/jetty/http/gzip/GzipResponseWrapperImpl.java delete mode 100644 jetty-http/src/main/java/org/eclipse/jetty/http/gzip/GzipStreamImpl.java diff --git a/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/AbstractCompressedResponseWrapper.java b/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/AbstractCompressedResponseWrapper.java deleted file mode 100644 index 95c69109e99..00000000000 --- a/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/AbstractCompressedResponseWrapper.java +++ /dev/null @@ -1,412 +0,0 @@ -// ======================================================================== -// Copyright (c) 2009-2009 Mort Bay Consulting Pty. Ltd. -// ------------------------------------------------------------------------ -// All rights reserved. This program and the accompanying materials -// are made available under the terms of the Eclipse Public License v1.0 -// and Apache License v2.0 which accompanies this distribution. -// The Eclipse Public License is available at -// http://www.eclipse.org/legal/epl-v10.html -// The Apache License v2.0 is available at -// http://www.opensource.org/licenses/apache2.0.php -// You may elect to redistribute this code under either of these licenses. -// ======================================================================== - -package org.eclipse.jetty.http.gzip; - -import java.io.IOException; -import java.io.OutputStream; -import java.io.OutputStreamWriter; -import java.io.PrintWriter; -import java.io.UnsupportedEncodingException; -import java.util.Set; - -import javax.servlet.ServletOutputStream; -import javax.servlet.http.HttpServletRequest; -import javax.servlet.http.HttpServletResponse; -import javax.servlet.http.HttpServletResponseWrapper; - -import org.eclipse.jetty.util.StringUtil; - -/*------------------------------------------------------------ */ -/** - * Skeletal implementation of the CompressedResponseWrapper interface. - * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper - */ -public abstract class AbstractCompressedResponseWrapper extends HttpServletResponseWrapper implements CompressedResponseWrapper -{ - - public static final int DEFAULT_BUFFER_SIZE = 8192; - public static final int DEFAULT_MIN_COMPRESS_SIZE = 256; - - private Set<String> _mimeTypes; - private int _bufferSize=DEFAULT_BUFFER_SIZE; - private int _minCompressSize=DEFAULT_MIN_COMPRESS_SIZE; - private HttpServletRequest _request; - - private PrintWriter _writer; - private CompressedStream _compressedStream; - private long _contentLength=-1; - private boolean _noCompression; - - public AbstractCompressedResponseWrapper(HttpServletRequest request, HttpServletResponse response) - { - super(response); - _request = request; - } - - /* ------------------------------------------------------------ */ - /** - * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#setMimeTypes(java.util.Set) - */ - public void setMimeTypes(Set<String> mimeTypes) - { - _mimeTypes = mimeTypes; - } - - /* ------------------------------------------------------------ */ - /** - * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#setBufferSize(int) - */ - @Override - public void setBufferSize(int bufferSize) - { - _bufferSize = bufferSize; - } - - /* ------------------------------------------------------------ */ - /** - * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#setMinCompressSize(int) - */ - public void setMinCompressSize(int minCompressSize) - { - _minCompressSize = minCompressSize; - } - - /* ------------------------------------------------------------ */ - /** - * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#setContentType(java.lang.String) - */ - @Override - public void setContentType(String ct) - { - super.setContentType(ct); - - if (ct!=null) - { - int colon=ct.indexOf(";"); - if (colon>0) - ct=ct.substring(0,colon); - } - - if ((_compressedStream==null || _compressedStream.getOutputStream()==null) && - (_mimeTypes==null && ct!=null && ct.contains("gzip") || - _mimeTypes!=null && (ct==null||!_mimeTypes.contains(StringUtil.asciiToLowerCase(ct))))) - { - noCompression(); - } - } - - /* ------------------------------------------------------------ */ - /** - * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#setStatus(int, java.lang.String) - */ - @Override - public void setStatus(int sc, String sm) - { - super.setStatus(sc,sm); - if (sc<200 || sc==204 || sc==205 || sc>=300) - noCompression(); - } - - /* ------------------------------------------------------------ */ - /** - * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#setStatus(int) - */ - @Override - public void setStatus(int sc) - { - super.setStatus(sc); - if (sc<200 || sc==204 || sc==205 ||sc>=300) - noCompression(); - } - - /* ------------------------------------------------------------ */ - /** - * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#setContentLength(int) - */ - @Override - public void setContentLength(int length) - { - setContentLength((long)length); - } - - protected void setContentLength(long length) - { - _contentLength=length; - if (_compressedStream!=null) - _compressedStream.setContentLength(length); - else if (_noCompression && _contentLength>=0) - { - HttpServletResponse response = (HttpServletResponse)getResponse(); - if(_contentLength<Integer.MAX_VALUE) - { - response.setContentLength((int)_contentLength); - } - else - { - response.setHeader("Content-Length", Long.toString(_contentLength)); - } - } - } - - /* ------------------------------------------------------------ */ - /** - * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#addHeader(java.lang.String, java.lang.String) - */ - @Override - public void addHeader(String name, String value) - { - if ("content-length".equalsIgnoreCase(name)) - { - _contentLength=Long.parseLong(value); - if (_compressedStream!=null) - _compressedStream.setContentLength(_contentLength); - } - else if ("content-type".equalsIgnoreCase(name)) - { - setContentType(value); - } - else if ("content-encoding".equalsIgnoreCase(name)) - { - super.addHeader(name,value); - if (!isCommitted()) - { - noCompression(); - } - } - else - super.addHeader(name,value); - } - - /* ------------------------------------------------------------ */ - /** - * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#flushBuffer() - */ - @Override - public void flushBuffer() throws IOException - { - if (_writer!=null) - _writer.flush(); - if (_compressedStream!=null) - _compressedStream.finish(); - else - getResponse().flushBuffer(); - } - - /* ------------------------------------------------------------ */ - /** - * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#reset() - */ - @Override - public void reset() - { - super.reset(); - if (_compressedStream!=null) - _compressedStream.resetBuffer(); - _writer=null; - _compressedStream=null; - _noCompression=false; - _contentLength=-1; - } - - /* ------------------------------------------------------------ */ - /** - * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#resetBuffer() - */ - @Override - public void resetBuffer() - { - super.resetBuffer(); - if (_compressedStream!=null) - _compressedStream.resetBuffer(); - _writer=null; - _compressedStream=null; - } - - /* ------------------------------------------------------------ */ - /** - * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#sendError(int, java.lang.String) - */ - @Override - public void sendError(int sc, String msg) throws IOException - { - resetBuffer(); - super.sendError(sc,msg); - } - - /* ------------------------------------------------------------ */ - /** - * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#sendError(int) - */ - @Override - public void sendError(int sc) throws IOException - { - resetBuffer(); - super.sendError(sc); - } - - /* ------------------------------------------------------------ */ - /** - * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#sendRedirect(java.lang.String) - */ - @Override - public void sendRedirect(String location) throws IOException - { - resetBuffer(); - super.sendRedirect(location); - } - - /* ------------------------------------------------------------ */ - /** - * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#noCompression() - */ - public void noCompression() - { - _noCompression=true; - if (_compressedStream!=null) - { - try - { - _compressedStream.doNotCompress(); - } - catch (IOException e) - { - throw new IllegalStateException(e); - } - } - } - - /* ------------------------------------------------------------ */ - /** - * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#finish() - */ - public void finish() throws IOException - { - if (_writer!=null && !_compressedStream.isClosed()) - _writer.flush(); - if (_compressedStream!=null) - _compressedStream.finish(); - } - - /* ------------------------------------------------------------ */ - /** - * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#setHeader(java.lang.String, java.lang.String) - */ - @Override - public void setHeader(String name, String value) - { - if ("content-length".equalsIgnoreCase(name)) - { - setContentLength(Long.parseLong(value)); - } - else if ("content-type".equalsIgnoreCase(name)) - { - setContentType(value); - } - else if ("content-encoding".equalsIgnoreCase(name)) - { - super.setHeader(name,value); - if (!isCommitted()) - { - noCompression(); - } - } - else - super.setHeader(name,value); - } - - /* ------------------------------------------------------------ */ - /** - * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#getOutputStream() - */ - @Override - public ServletOutputStream getOutputStream() throws IOException - { - if (_compressedStream==null) - { - if (getResponse().isCommitted() || _noCompression) - { - setContentLength(_contentLength); - return getResponse().getOutputStream(); - } - - _compressedStream=newCompressedStream(_request,(HttpServletResponse)getResponse(),_contentLength,_bufferSize,_minCompressSize); - } - else if (_writer!=null) - throw new IllegalStateException("getWriter() called"); - - return (ServletOutputStream)_compressedStream; - } - - /* ------------------------------------------------------------ */ - /** - * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#getWriter() - */ - @Override - public PrintWriter getWriter() throws IOException - { - if (_writer==null) - { - if (_compressedStream!=null) - throw new IllegalStateException("getOutputStream() called"); - - if (getResponse().isCommitted() || _noCompression) - { - setContentLength(_contentLength); - return getResponse().getWriter(); - } - - _compressedStream=newCompressedStream(_request,(HttpServletResponse)getResponse(),_contentLength,_bufferSize,_minCompressSize); - _writer=newWriter((OutputStream)_compressedStream,getCharacterEncoding()); - } - return _writer; - } - - /* ------------------------------------------------------------ */ - /** - * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#setIntHeader(java.lang.String, int) - */ - @Override - public void setIntHeader(String name, int value) - { - if ("content-length".equalsIgnoreCase(name)) - { - _contentLength=value; - if (_compressedStream!=null) - _compressedStream.setContentLength(_contentLength); - } - else - super.setIntHeader(name,value); - } - - /* ------------------------------------------------------------ */ - /** - * Allows derived implementations to replace PrintWriter implementation. - * - * @param out the out - * @param encoding the encoding - * @return the prints the writer - * @throws UnsupportedEncodingException the unsupported encoding exception - */ - protected PrintWriter newWriter(OutputStream out,String encoding) throws UnsupportedEncodingException - { - return encoding==null?new PrintWriter(out):new PrintWriter(new OutputStreamWriter(out,encoding)); - } - - /* ------------------------------------------------------------ */ - /** - *@return the underlying CompressedStream implementation - */ - protected abstract CompressedStream newCompressedStream(HttpServletRequest _request, HttpServletResponse response, long _contentLength2, int _bufferSize2, int _minCompressedSize2) throws IOException; - -} \ No newline at end of file diff --git a/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/AbstractCompressedStream.java b/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/AbstractCompressedStream.java index 0e8e1f18c9c..f879610be29 100644 --- a/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/AbstractCompressedStream.java +++ b/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/AbstractCompressedStream.java @@ -13,6 +13,8 @@ package org.eclipse.jetty.http.gzip; +import java.io.Closeable; +import java.io.Flushable; import java.io.IOException; import java.io.OutputStream; import java.io.OutputStreamWriter; @@ -32,8 +34,9 @@ import org.eclipse.jetty.util.ByteArrayOutputStream2; * Major work and configuration is done here. Subclasses using different kinds of compression only have to implement the abstract methods doCompress() and * setContentEncoding() using the desired compression and setting the appropiate Content-Encoding header string. */ -public abstract class AbstractCompressedStream extends ServletOutputStream implements CompressedStream +public abstract class AbstractCompressedStream extends ServletOutputStream { + private final String _encoding; protected HttpServletRequest _request; protected HttpServletResponse _response; protected OutputStream _out; @@ -61,9 +64,10 @@ public abstract class AbstractCompressedStream extends ServletOutputStream imple * @throws IOException * Signals that an I/O exception has occurred. */ - public AbstractCompressedStream(HttpServletRequest request, HttpServletResponse response, long contentLength, int bufferSize, int minCompressSize) + public AbstractCompressedStream(String encoding,HttpServletRequest request, HttpServletResponse response, long contentLength, int bufferSize, int minCompressSize) throws IOException { + _encoding=encoding; _request = request; _response = response; _contentLength = contentLength; @@ -232,7 +236,9 @@ public abstract class AbstractCompressedStream extends ServletOutputStream imple if (_response.isCommitted()) throw new IllegalStateException(); - if (setContentEncoding()) + setHeader("Content-Encoding", _encoding); + + if (_response.containsHeader("Content-Encoding")) { _out=_compressedOutputStream=createStream(); @@ -325,12 +331,10 @@ public abstract class AbstractCompressedStream extends ServletOutputStream imple return encoding == null?new PrintWriter(out):new PrintWriter(new OutputStreamWriter(out,encoding)); } - /** - * Sets the content encoding. - * - * @return true, if successful - */ - protected abstract boolean setContentEncoding(); + protected void setHeader(String name,String value) + { + _response.setHeader(name, value); + } /** * Create the stream fitting to the underlying compression type. diff --git a/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/CompressedResponseWrapper.java b/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/CompressedResponseWrapper.java index 14bdc6bb612..1431f3868e2 100644 --- a/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/CompressedResponseWrapper.java +++ b/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/CompressedResponseWrapper.java @@ -14,45 +14,398 @@ package org.eclipse.jetty.http.gzip; import java.io.IOException; +import java.io.OutputStream; +import java.io.OutputStreamWriter; +import java.io.PrintWriter; +import java.io.UnsupportedEncodingException; import java.util.Set; +import javax.servlet.ServletOutputStream; +import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; +import javax.servlet.http.HttpServletResponseWrapper; -/* ------------------------------------------------------------ */ +import org.eclipse.jetty.util.StringUtil; + +/*------------------------------------------------------------ */ /** - * A ResponseWrapper interface that adds compress functionality to a ResponseWrapper */ -public interface CompressedResponseWrapper extends HttpServletResponse +public abstract class CompressedResponseWrapper extends HttpServletResponseWrapper { + + public static final int DEFAULT_BUFFER_SIZE = 8192; + public static final int DEFAULT_MIN_COMPRESS_SIZE = 256; + + private Set<String> _mimeTypes; + private int _bufferSize=DEFAULT_BUFFER_SIZE; + private int _minCompressSize=DEFAULT_MIN_COMPRESS_SIZE; + protected HttpServletRequest _request; - /** - * Sets the mime types. - * - * @param mimeTypes - * the new mime types - */ - public void setMimeTypes(Set<String> mimeTypes); + private PrintWriter _writer; + private AbstractCompressedStream _compressedStream; + private long _contentLength=-1; + private boolean _noCompression; - /** - * Sets the min compress size. - * - * @param minCompressSize - * the new min compress size - */ - public void setMinCompressSize(int minCompressSize); + public CompressedResponseWrapper(HttpServletRequest request, HttpServletResponse response) + { + super(response); + _request = request; + } /* ------------------------------------------------------------ */ /** - * No compression. + * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#setMimeTypes(java.util.Set) */ - public void noCompression(); + public void setMimeTypes(Set<String> mimeTypes) + { + _mimeTypes = mimeTypes; + } + /* ------------------------------------------------------------ */ /** - * Finish. - * - * @throws IOException - * Signals that an I/O exception has occurred. + * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#setBufferSize(int) */ - public void finish() throws IOException; + @Override + public void setBufferSize(int bufferSize) + { + _bufferSize = bufferSize; + } + + /* ------------------------------------------------------------ */ + /** + * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#setMinCompressSize(int) + */ + public void setMinCompressSize(int minCompressSize) + { + _minCompressSize = minCompressSize; + } + + /* ------------------------------------------------------------ */ + /** + * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#setContentType(java.lang.String) + */ + @Override + public void setContentType(String ct) + { + super.setContentType(ct); + + if (ct!=null) + { + int colon=ct.indexOf(";"); + if (colon>0) + ct=ct.substring(0,colon); + } + + if ((_compressedStream==null || _compressedStream.getOutputStream()==null) && + (_mimeTypes==null && ct!=null && ct.contains("gzip") || + _mimeTypes!=null && (ct==null||!_mimeTypes.contains(StringUtil.asciiToLowerCase(ct))))) + { + noCompression(); + } + } + + /* ------------------------------------------------------------ */ + /** + * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#setStatus(int, java.lang.String) + */ + @Override + public void setStatus(int sc, String sm) + { + super.setStatus(sc,sm); + if (sc<200 || sc==204 || sc==205 || sc>=300) + noCompression(); + } + + /* ------------------------------------------------------------ */ + /** + * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#setStatus(int) + */ + @Override + public void setStatus(int sc) + { + super.setStatus(sc); + if (sc<200 || sc==204 || sc==205 ||sc>=300) + noCompression(); + } + + /* ------------------------------------------------------------ */ + /** + * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#setContentLength(int) + */ + @Override + public void setContentLength(int length) + { + setContentLength((long)length); + } + + /* ------------------------------------------------------------ */ + protected void setContentLength(long length) + { + _contentLength=length; + if (_compressedStream!=null) + _compressedStream.setContentLength(length); + else if (_noCompression && _contentLength>=0) + { + HttpServletResponse response = (HttpServletResponse)getResponse(); + if(_contentLength<Integer.MAX_VALUE) + { + response.setContentLength((int)_contentLength); + } + else + { + response.setHeader("Content-Length", Long.toString(_contentLength)); + } + } + } + + /* ------------------------------------------------------------ */ + /** + * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#addHeader(java.lang.String, java.lang.String) + */ + @Override + public void addHeader(String name, String value) + { + if ("content-length".equalsIgnoreCase(name)) + { + _contentLength=Long.parseLong(value); + if (_compressedStream!=null) + _compressedStream.setContentLength(_contentLength); + } + else if ("content-type".equalsIgnoreCase(name)) + { + setContentType(value); + } + else if ("content-encoding".equalsIgnoreCase(name)) + { + super.addHeader(name,value); + if (!isCommitted()) + { + noCompression(); + } + } + else + super.addHeader(name,value); + } + + /* ------------------------------------------------------------ */ + /** + * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#flushBuffer() + */ + @Override + public void flushBuffer() throws IOException + { + if (_writer!=null) + _writer.flush(); + if (_compressedStream!=null) + _compressedStream.finish(); + else + getResponse().flushBuffer(); + } + + /* ------------------------------------------------------------ */ + /** + * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#reset() + */ + @Override + public void reset() + { + super.reset(); + if (_compressedStream!=null) + _compressedStream.resetBuffer(); + _writer=null; + _compressedStream=null; + _noCompression=false; + _contentLength=-1; + } + + /* ------------------------------------------------------------ */ + /** + * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#resetBuffer() + */ + @Override + public void resetBuffer() + { + super.resetBuffer(); + if (_compressedStream!=null) + _compressedStream.resetBuffer(); + _writer=null; + _compressedStream=null; + } + + /* ------------------------------------------------------------ */ + /** + * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#sendError(int, java.lang.String) + */ + @Override + public void sendError(int sc, String msg) throws IOException + { + resetBuffer(); + super.sendError(sc,msg); + } + + /* ------------------------------------------------------------ */ + /** + * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#sendError(int) + */ + @Override + public void sendError(int sc) throws IOException + { + resetBuffer(); + super.sendError(sc); + } + + /* ------------------------------------------------------------ */ + /** + * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#sendRedirect(java.lang.String) + */ + @Override + public void sendRedirect(String location) throws IOException + { + resetBuffer(); + super.sendRedirect(location); + } + + /* ------------------------------------------------------------ */ + /** + * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#noCompression() + */ + public void noCompression() + { + _noCompression=true; + if (_compressedStream!=null) + { + try + { + _compressedStream.doNotCompress(); + } + catch (IOException e) + { + throw new IllegalStateException(e); + } + } + } + + /* ------------------------------------------------------------ */ + /** + * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#finish() + */ + public void finish() throws IOException + { + if (_writer!=null && !_compressedStream.isClosed()) + _writer.flush(); + if (_compressedStream!=null) + _compressedStream.finish(); + } + + /* ------------------------------------------------------------ */ + /** + * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#setHeader(java.lang.String, java.lang.String) + */ + @Override + public void setHeader(String name, String value) + { + if ("content-length".equalsIgnoreCase(name)) + { + setContentLength(Long.parseLong(value)); + } + else if ("content-type".equalsIgnoreCase(name)) + { + setContentType(value); + } + else if ("content-encoding".equalsIgnoreCase(name)) + { + super.setHeader(name,value); + if (!isCommitted()) + { + noCompression(); + } + } + else + super.setHeader(name,value); + } + + /* ------------------------------------------------------------ */ + /** + * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#getOutputStream() + */ + @Override + public ServletOutputStream getOutputStream() throws IOException + { + if (_compressedStream==null) + { + if (getResponse().isCommitted() || _noCompression) + { + setContentLength(_contentLength); + return getResponse().getOutputStream(); + } + + _compressedStream=newCompressedStream(_request,(HttpServletResponse)getResponse(),_contentLength,_bufferSize,_minCompressSize); + } + else if (_writer!=null) + throw new IllegalStateException("getWriter() called"); + + return (ServletOutputStream)_compressedStream; + } + + /* ------------------------------------------------------------ */ + /** + * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#getWriter() + */ + @Override + public PrintWriter getWriter() throws IOException + { + if (_writer==null) + { + if (_compressedStream!=null) + throw new IllegalStateException("getOutputStream() called"); + + if (getResponse().isCommitted() || _noCompression) + { + setContentLength(_contentLength); + return getResponse().getWriter(); + } + + _compressedStream=newCompressedStream(_request,(HttpServletResponse)getResponse(),_contentLength,_bufferSize,_minCompressSize); + _writer=newWriter((OutputStream)_compressedStream,getCharacterEncoding()); + } + return _writer; + } + + /* ------------------------------------------------------------ */ + /** + * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#setIntHeader(java.lang.String, int) + */ + @Override + public void setIntHeader(String name, int value) + { + if ("content-length".equalsIgnoreCase(name)) + { + _contentLength=value; + if (_compressedStream!=null) + _compressedStream.setContentLength(_contentLength); + } + else + super.setIntHeader(name,value); + } + + /* ------------------------------------------------------------ */ + /** + * Allows derived implementations to replace PrintWriter implementation. + * + * @param out the out + * @param encoding the encoding + * @return the prints the writer + * @throws UnsupportedEncodingException the unsupported encoding exception + */ + protected PrintWriter newWriter(OutputStream out,String encoding) throws UnsupportedEncodingException + { + return encoding==null?new PrintWriter(out):new PrintWriter(new OutputStreamWriter(out,encoding)); + } + + /* ------------------------------------------------------------ */ + /** + *@return the underlying CompressedStream implementation + */ + protected abstract AbstractCompressedStream newCompressedStream(HttpServletRequest _request, HttpServletResponse response, long _contentLength2, int _bufferSize2, int _minCompressedSize2) throws IOException; } \ No newline at end of file diff --git a/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/CompressedStream.java b/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/CompressedStream.java deleted file mode 100644 index 751b2f05d1e..00000000000 --- a/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/CompressedStream.java +++ /dev/null @@ -1,77 +0,0 @@ -// ======================================================================== -// Copyright (c) 2009-2009 Mort Bay Consulting Pty. Ltd. -// ------------------------------------------------------------------------ -// All rights reserved. This program and the accompanying materials -// are made available under the terms of the Eclipse Public License v1.0 -// and Apache License v2.0 which accompanies this distribution. -// The Eclipse Public License is available at -// http://www.eclipse.org/legal/epl-v10.html -// The Apache License v2.0 is available at -// http://www.opensource.org/licenses/apache2.0.php -// You may elect to redistribute this code under either of these licenses. -// ======================================================================== - -package org.eclipse.jetty.http.gzip; - -import java.io.Closeable; -import java.io.Flushable; -import java.io.IOException; -import java.io.OutputStream; - -/* ------------------------------------------------------------ */ -/** -* Interface for compressed streams -*/ -public interface CompressedStream extends Closeable, Flushable -{ - - /** - * Reset buffer. - */ - public void resetBuffer(); - - /** - * Sets the content length. - * - * @param length - * the new content length - */ - public void setContentLength(long length); - - /* ------------------------------------------------------------ */ - /** - * @return true if stream is closed - */ - public boolean isClosed(); - - /** - * Do compress. - * - * @throws IOException - * Signals that an I/O exception has occurred. - */ - public void doCompress() throws IOException; - - /** - * Do not compress. - * - * @throws IOException - * Signals that an I/O exception has occurred. - */ - public void doNotCompress() throws IOException; - - /** - * Finish. - * - * @throws IOException - * Signals that an I/O exception has occurred. - */ - public void finish() throws IOException; - - /* ------------------------------------------------------------ */ - /** - * @return the {@link OutputStream} - */ - public OutputStream getOutputStream(); - -} \ No newline at end of file diff --git a/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/CompressionType.java b/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/CompressionType.java deleted file mode 100644 index 4b75c2631d3..00000000000 --- a/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/CompressionType.java +++ /dev/null @@ -1,48 +0,0 @@ -// ======================================================================== -// Copyright (c) 2009-2009 Mort Bay Consulting Pty. Ltd. -// ------------------------------------------------------------------------ -// All rights reserved. This program and the accompanying materials -// are made available under the terms of the Eclipse Public License v1.0 -// and Apache License v2.0 which accompanies this distribution. -// The Eclipse Public License is available at -// http://www.eclipse.org/legal/epl-v10.html -// The Apache License v2.0 is available at -// http://www.opensource.org/licenses/apache2.0.php -// You may elect to redistribute this code under either of these licenses. -// ======================================================================== - -package org.eclipse.jetty.http.gzip; - -public enum CompressionType -{ - GZIP("gzip"), DEFLATE("deflate"), UNSUPPORTED("unsupported"); - - private final String encodingHeader; - - private CompressionType(String encodingHeader) - { - this.encodingHeader = encodingHeader; - } - - public String getEncodingHeader() - { - return encodingHeader; - } - - public static CompressionType getByEncodingHeader(String encodingHeader) - { - // prefer gzip over deflate - if (encodingHeader.toLowerCase().contains(CompressionType.GZIP.encodingHeader)) - { - return CompressionType.GZIP; - } - else if (encodingHeader.toLowerCase().contains(CompressionType.DEFLATE.encodingHeader)) - { - return CompressionType.DEFLATE; - } - else - { - return CompressionType.UNSUPPORTED; - } - } -} \ No newline at end of file diff --git a/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/DeflateResponseWrapperImpl.java b/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/DeflateResponseWrapperImpl.java deleted file mode 100644 index 9cf5fe02673..00000000000 --- a/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/DeflateResponseWrapperImpl.java +++ /dev/null @@ -1,54 +0,0 @@ -// ======================================================================== -// Copyright (c) Webtide LLC -// ------------------------------------------------------------------------ -// All rights reserved. This program and the accompanying materials -// are made available under the terms of the Eclipse Public License v1.0 -// and Apache License v2.0 which accompanies this distribution. -// The Eclipse Public License is available at -// http://www.eclipse.org/legal/epl-v10.html -// The Apache License v2.0 is available at -// http://www.opensource.org/licenses/apache2.0.php -// You may elect to redistribute this code under either of these licenses. -// ======================================================================== - - -package org.eclipse.jetty.http.gzip; - -import java.io.IOException; -import javax.servlet.http.HttpServletRequest; -import javax.servlet.http.HttpServletResponse; - -/* ------------------------------------------------------------ */ -/** - */ -public class DeflateResponseWrapperImpl extends AbstractCompressedResponseWrapper -{ - /** - * Instantiates a new deflate response wrapper. - * - * @param request the request - * @param response the response - */ - public DeflateResponseWrapperImpl(HttpServletRequest request, HttpServletResponse response) - { - super(request,response); - } - - - /* ------------------------------------------------------------ */ - /** - * @param request the request - * @param response the response - * @param contentLength the content length - * @param bufferSize the buffer size - * @param minCompressSize the min compress size - * @return the deflate stream - * @throws IOException Signals that an I/O exception has occurred. - */ - @Override - protected CompressedStream newCompressedStream(HttpServletRequest request,HttpServletResponse response,long contentLength,int bufferSize, int minCompressSize) throws IOException - { - return new DeflateStreamImpl(request,response,contentLength,bufferSize,minCompressSize); - } -} - diff --git a/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/DeflateStreamImpl.java b/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/DeflateStreamImpl.java deleted file mode 100644 index 16e3d82750d..00000000000 --- a/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/DeflateStreamImpl.java +++ /dev/null @@ -1,55 +0,0 @@ -// ======================================================================== -// Copyright (c) Webtide LLC -// ------------------------------------------------------------------------ -// All rights reserved. This program and the accompanying materials -// are made available under the terms of the Eclipse Public License v1.0 -// and Apache License v2.0 which accompanies this distribution. -// The Eclipse Public License is available at -// http://www.eclipse.org/legal/epl-v10.html -// The Apache License v2.0 is available at -// http://www.opensource.org/licenses/apache2.0.php -// You may elect to redistribute this code under either of these licenses. -// ======================================================================== - -package org.eclipse.jetty.http.gzip; - -import java.io.IOException; -import java.util.zip.DeflaterOutputStream; - -import javax.servlet.http.HttpServletRequest; -import javax.servlet.http.HttpServletResponse; - - -/* ------------------------------------------------------------ */ -/** - * Compressed Stream implementation using deflate to compress - */ -public class DeflateStreamImpl extends AbstractCompressedStream implements CompressedStream -{ - public DeflateStreamImpl(HttpServletRequest request, HttpServletResponse response, long contentLength, int bufferSize, int minGzipSize) throws IOException - { - super(request,response,contentLength,bufferSize,minGzipSize); - } - - /** - * Sets the Content-Encoding header to deflate. - * - * @return true, if successful - */ - @Override - protected boolean setContentEncoding() - { - _response.setHeader("Content-Encoding", CompressionType.DEFLATE.getEncodingHeader()); - return _response.containsHeader("Content-Encoding"); - } - - /** - * @return a new DeflaterOutputStream backed by _response.getOutputStream() - */ - @Override - protected DeflaterOutputStream createStream() throws IOException - { - return new DeflaterOutputStream(_response.getOutputStream()); - } -} - diff --git a/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/GzipResponseWrapperImpl.java b/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/GzipResponseWrapperImpl.java deleted file mode 100644 index f434ad27c3f..00000000000 --- a/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/GzipResponseWrapperImpl.java +++ /dev/null @@ -1,53 +0,0 @@ -// ======================================================================== -// Copyright (c) Webtide LLC -// ------------------------------------------------------------------------ -// All rights reserved. This program and the accompanying materials -// are made available under the terms of the Eclipse Public License v1.0 -// and Apache License v2.0 which accompanies this distribution. -// The Eclipse Public License is available at -// http://www.eclipse.org/legal/epl-v10.html -// The Apache License v2.0 is available at -// http://www.opensource.org/licenses/apache2.0.php -// You may elect to redistribute this code under either of these licenses. -// ======================================================================== - -package org.eclipse.jetty.http.gzip; - -import java.io.IOException; -import javax.servlet.http.HttpServletRequest; -import javax.servlet.http.HttpServletResponse; - -/* ------------------------------------------------------------ */ -/** - */ -public class GzipResponseWrapperImpl extends AbstractCompressedResponseWrapper -{ - /** - * Instantiates a new gzip response wrapper. - * - * @param request the request - * @param response the response - */ - public GzipResponseWrapperImpl(HttpServletRequest request, HttpServletResponse response) - { - super(request,response); - } - - - /* ------------------------------------------------------------ */ - /** - * @param request the request - * @param response the response - * @param contentLength the content length - * @param bufferSize the buffer size - * @param minCompressSize the min gzip size - * @return the gzip stream - * @throws IOException Signals that an I/O exception has occurred. - */ - @Override - protected CompressedStream newCompressedStream(HttpServletRequest request,HttpServletResponse response,long contentLength,int bufferSize, int minCompressSize) throws IOException - { - return new GzipStreamImpl(request,response,contentLength,bufferSize,minCompressSize); - } -} - diff --git a/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/GzipStreamImpl.java b/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/GzipStreamImpl.java deleted file mode 100644 index 218aebca38d..00000000000 --- a/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/GzipStreamImpl.java +++ /dev/null @@ -1,56 +0,0 @@ -// ======================================================================== -// Copyright (c) Webtide LLC -// ------------------------------------------------------------------------ -// All rights reserved. This program and the accompanying materials -// are made available under the terms of the Eclipse Public License v1.0 -// and Apache License v2.0 which accompanies this distribution. -// The Eclipse Public License is available at -// http://www.eclipse.org/legal/epl-v10.html -// The Apache License v2.0 is available at -// http://www.opensource.org/licenses/apache2.0.php -// You may elect to redistribute this code under either of these licenses. -// ======================================================================== - -package org.eclipse.jetty.http.gzip; - -import java.io.IOException; -import java.util.zip.DeflaterOutputStream; -import java.util.zip.GZIPOutputStream; - -import javax.servlet.http.HttpServletRequest; -import javax.servlet.http.HttpServletResponse; - - -/* ------------------------------------------------------------ */ -/** - * Compressed Stream implementation using gzip to compress - */ -public class GzipStreamImpl extends AbstractCompressedStream implements CompressedStream -{ - public GzipStreamImpl(HttpServletRequest request, HttpServletResponse response, long contentLength, int bufferSize, int minGzipSize) throws IOException - { - super(request,response,contentLength,bufferSize,minGzipSize); - } - - /** - * Sets the Content-Encoding header to gzip. - * - * @return true, if successful - */ - @Override - protected boolean setContentEncoding() - { - _response.setHeader("Content-Encoding", CompressionType.GZIP.getEncodingHeader()); - return _response.containsHeader("Content-Encoding"); - } - - /** - * @return a new GZIPOutputStream backed by _response.getOutputStream() - */ - @Override - protected DeflaterOutputStream createStream() throws IOException - { - return new GZIPOutputStream(_response.getOutputStream(),_bufferSize); - } -} - diff --git a/jetty-server/src/main/java/org/eclipse/jetty/server/handler/GzipHandler.java b/jetty-server/src/main/java/org/eclipse/jetty/server/handler/GzipHandler.java index 83bd42e152b..72af6011c0e 100644 --- a/jetty-server/src/main/java/org/eclipse/jetty/server/handler/GzipHandler.java +++ b/jetty-server/src/main/java/org/eclipse/jetty/server/handler/GzipHandler.java @@ -21,6 +21,8 @@ import java.io.UnsupportedEncodingException; import java.util.HashSet; import java.util.Set; import java.util.StringTokenizer; +import java.util.zip.DeflaterOutputStream; +import java.util.zip.GZIPOutputStream; import javax.servlet.ServletException; import javax.servlet.http.HttpServletRequest; @@ -30,7 +32,8 @@ import org.eclipse.jetty.continuation.Continuation; import org.eclipse.jetty.continuation.ContinuationListener; import org.eclipse.jetty.continuation.ContinuationSupport; import org.eclipse.jetty.http.HttpMethods; -import org.eclipse.jetty.http.gzip.GzipResponseWrapperImpl; +import org.eclipse.jetty.http.gzip.CompressedResponseWrapper; +import org.eclipse.jetty.http.gzip.AbstractCompressedStream; import org.eclipse.jetty.server.Request; import org.eclipse.jetty.util.log.Log; import org.eclipse.jetty.util.log.Logger; @@ -222,7 +225,7 @@ public class GzipHandler extends HandlerWrapper } } - final GzipResponseWrapperImpl wrappedResponse = newGzipResponseWrapper(request,response); + final CompressedResponseWrapper wrappedResponse = newGzipResponseWrapper(request,response); boolean exceptional=true; try @@ -276,9 +279,9 @@ public class GzipHandler extends HandlerWrapper * @param response the response * @return the gzip response wrapper */ - protected GzipResponseWrapperImpl newGzipResponseWrapper(HttpServletRequest request, HttpServletResponse response) + protected CompressedResponseWrapper newGzipResponseWrapper(HttpServletRequest request, HttpServletResponse response) { - return new GzipResponseWrapperImpl(request, response) + return new CompressedResponseWrapper(request,response) { { super.setMimeTypes(GzipHandler.this._mimeTypes); @@ -286,6 +289,19 @@ public class GzipHandler extends HandlerWrapper super.setMinCompressSize(GzipHandler.this._minGzipSize); } + @Override + protected AbstractCompressedStream newCompressedStream(HttpServletRequest request,HttpServletResponse response,long contentLength,int bufferSize, int minCompressSize) throws IOException + { + return new AbstractCompressedStream("gzip",request,response,contentLength,bufferSize,minCompressSize) + { + @Override + protected DeflaterOutputStream createStream() throws IOException + { + return new GZIPOutputStream(_response.getOutputStream(),_bufferSize); + } + }; + } + @Override protected PrintWriter newWriter(OutputStream out,String encoding) throws UnsupportedEncodingException { diff --git a/jetty-servlets/src/main/java/org/eclipse/jetty/servlets/GzipFilter.java b/jetty-servlets/src/main/java/org/eclipse/jetty/servlets/GzipFilter.java index 266b71887bc..40564cae0e8 100644 --- a/jetty-servlets/src/main/java/org/eclipse/jetty/servlets/GzipFilter.java +++ b/jetty-servlets/src/main/java/org/eclipse/jetty/servlets/GzipFilter.java @@ -17,6 +17,8 @@ import java.util.HashSet; import java.util.Set; import java.util.StringTokenizer; import java.util.regex.Pattern; +import java.util.zip.DeflaterOutputStream; +import java.util.zip.GZIPOutputStream; import javax.servlet.FilterChain; import javax.servlet.FilterConfig; @@ -31,9 +33,7 @@ import org.eclipse.jetty.continuation.ContinuationListener; import org.eclipse.jetty.continuation.ContinuationSupport; import org.eclipse.jetty.http.HttpMethods; import org.eclipse.jetty.http.gzip.CompressedResponseWrapper; -import org.eclipse.jetty.http.gzip.CompressionType; -import org.eclipse.jetty.http.gzip.DeflateResponseWrapperImpl; -import org.eclipse.jetty.http.gzip.GzipResponseWrapperImpl; +import org.eclipse.jetty.http.gzip.AbstractCompressedStream; import org.eclipse.jetty.util.log.Log; import org.eclipse.jetty.util.log.Logger; @@ -67,6 +67,8 @@ import org.eclipse.jetty.util.log.Logger; public class GzipFilter extends UserAgentFilter { private static final Logger LOG = Log.getLogger(GzipFilter.class); + public final static String GZIP="gzip"; + public final static String DEFLATE="deflate"; protected Set<String> _mimeTypes; protected int _bufferSize=8192; @@ -147,7 +149,22 @@ public class GzipFilter extends UserAgentFilter public void destroy() { } - + + /* ------------------------------------------------------------ */ + public String selectCompression(String encodingHeader) + { + // TODO, this could be a little more robust. + // prefer gzip over deflate + if (encodingHeader!=null) + { + if (encodingHeader.toLowerCase().contains(GZIP)) + return GZIP; + if (encodingHeader.toLowerCase().contains(DEFLATE)) + return DEFLATE; + } + return null; + } + /* ------------------------------------------------------------ */ /** * @see org.eclipse.jetty.servlets.UserAgentFilter#doFilter(javax.servlet.ServletRequest, javax.servlet.ServletResponse, javax.servlet.FilterChain) @@ -160,9 +177,8 @@ public class GzipFilter extends UserAgentFilter HttpServletResponse response=(HttpServletResponse)res; String ae = request.getHeader("accept-encoding"); - CompressionType compressionType = CompressionType.getByEncodingHeader(ae); - if (ae != null && !compressionType.equals(CompressionType.UNSUPPORTED) && !response.containsHeader("Content-Encoding") - && !HttpMethods.HEAD.equalsIgnoreCase(request.getMethod())) + String compressionType = selectCompression(request.getHeader("accept-encoding")); + if (compressionType!=null && !response.containsHeader("Content-Encoding") && !HttpMethods.HEAD.equalsIgnoreCase(request.getMethod())) { String ua = getUserAgent(request); if (isExcludedAgent(ua)) @@ -207,16 +223,44 @@ public class GzipFilter extends UserAgentFilter } } - protected CompressedResponseWrapper createWrappedResponse(HttpServletRequest request, HttpServletResponse response, CompressionType compressionType) + protected CompressedResponseWrapper createWrappedResponse(HttpServletRequest request, HttpServletResponse response, final String compressionType) { CompressedResponseWrapper wrappedResponse = null; - if (compressionType.equals(CompressionType.GZIP)) + if (compressionType.equals(GZIP)) { - wrappedResponse = new GzipResponseWrapperImpl(request,response); + wrappedResponse = new CompressedResponseWrapper(request,response) + { + @Override + protected AbstractCompressedStream newCompressedStream(HttpServletRequest request,HttpServletResponse response,long contentLength,int bufferSize, int minCompressSize) throws IOException + { + return new AbstractCompressedStream(compressionType,request,response,contentLength,bufferSize,minCompressSize) + { + @Override + protected DeflaterOutputStream createStream() throws IOException + { + return new GZIPOutputStream(_response.getOutputStream(),_bufferSize); + } + }; + } + }; } - else if (compressionType.equals(CompressionType.DEFLATE)) + else if (compressionType.equals(DEFLATE)) { - wrappedResponse = new DeflateResponseWrapperImpl(request,response); + wrappedResponse = new CompressedResponseWrapper(request,response) + { + @Override + protected AbstractCompressedStream newCompressedStream(HttpServletRequest request,HttpServletResponse response,long contentLength,int bufferSize, int minCompressSize) throws IOException + { + return new AbstractCompressedStream(compressionType,request,response,contentLength,bufferSize,minCompressSize) + { + @Override + protected DeflaterOutputStream createStream() throws IOException + { + return new DeflaterOutputStream(_response.getOutputStream()); + } + }; + } + }; } else { @@ -226,7 +270,7 @@ public class GzipFilter extends UserAgentFilter return wrappedResponse; } - private void configureWrappedResponse(CompressedResponseWrapper wrappedResponse) + protected void configureWrappedResponse(CompressedResponseWrapper wrappedResponse) { wrappedResponse.setMimeTypes(_mimeTypes); wrappedResponse.setBufferSize(_bufferSize); diff --git a/jetty-servlets/src/main/java/org/eclipse/jetty/servlets/IncludableGzipFilter.java b/jetty-servlets/src/main/java/org/eclipse/jetty/servlets/IncludableGzipFilter.java index a325dee3a99..972393e1644 100644 --- a/jetty-servlets/src/main/java/org/eclipse/jetty/servlets/IncludableGzipFilter.java +++ b/jetty-servlets/src/main/java/org/eclipse/jetty/servlets/IncludableGzipFilter.java @@ -18,6 +18,8 @@ import java.io.OutputStream; import java.io.OutputStreamWriter; import java.io.PrintWriter; import java.io.UnsupportedEncodingException; +import java.util.zip.DeflaterOutputStream; +import java.util.zip.GZIPOutputStream; import javax.servlet.FilterConfig; import javax.servlet.ServletException; @@ -25,11 +27,7 @@ import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.eclipse.jetty.http.gzip.CompressedResponseWrapper; -import org.eclipse.jetty.http.gzip.CompressedStream; -import org.eclipse.jetty.http.gzip.CompressionType; -import org.eclipse.jetty.http.gzip.DeflateStreamImpl; -import org.eclipse.jetty.http.gzip.GzipResponseWrapperImpl; -import org.eclipse.jetty.http.gzip.GzipStreamImpl; +import org.eclipse.jetty.http.gzip.AbstractCompressedStream; import org.eclipse.jetty.io.UncheckedPrintWriter; /* ------------------------------------------------------------ */ @@ -58,43 +56,75 @@ public class IncludableGzipFilter extends GzipFilter _uncheckedPrintWriter=Boolean.valueOf(tmp).booleanValue(); } + /* ------------------------------------------------------------ */ + /** + * @see org.eclipse.jetty.servlets.GzipFilter#createWrappedResponse(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, java.lang.String) + */ @Override - protected CompressedResponseWrapper createWrappedResponse(HttpServletRequest request, HttpServletResponse response, CompressionType compressionType) + protected CompressedResponseWrapper createWrappedResponse(HttpServletRequest request, HttpServletResponse response, final String compressionType) { - return new IncludableResponseWrapper(request,response); + CompressedResponseWrapper wrappedResponse = null; + if (compressionType.equals(GZIP)) + { + wrappedResponse = new IncludableResponseWrapper(request,response) + { + @Override + protected AbstractCompressedStream newCompressedStream(HttpServletRequest request,HttpServletResponse response,long contentLength,int bufferSize, int minCompressSize) throws IOException + { + return new AbstractCompressedStream(compressionType,request,response,contentLength,bufferSize,minCompressSize) + { + @Override + protected DeflaterOutputStream createStream() throws IOException + { + return new GZIPOutputStream(_response.getOutputStream(),_bufferSize); + } + }; + } + }; + } + else if (compressionType.equals(DEFLATE)) + { + wrappedResponse = new IncludableResponseWrapper(request,response) + { + @Override + protected AbstractCompressedStream newCompressedStream(HttpServletRequest request,HttpServletResponse response,long contentLength,int bufferSize, int minCompressSize) throws IOException + { + return new AbstractCompressedStream(compressionType,request,response,contentLength,bufferSize,minCompressSize) + { + @Override + protected DeflaterOutputStream createStream() throws IOException + { + return new DeflaterOutputStream(_response.getOutputStream()); + } + }; + } + }; + } + else + { + throw new IllegalStateException(compressionType + " not supported"); + } + configureWrappedResponse(wrappedResponse); + return wrappedResponse; } - - public class IncludableResponseWrapper extends GzipResponseWrapperImpl + + + // Extend CompressedResponseWrapper to be able to set headers during include and to create unchecked printwriters + private abstract class IncludableResponseWrapper extends CompressedResponseWrapper { public IncludableResponseWrapper(HttpServletRequest request, HttpServletResponse response) { super(request,response); - - super.setMimeTypes(IncludableGzipFilter.this._mimeTypes); - super.setBufferSize(IncludableGzipFilter.this._bufferSize); - super.setMinCompressSize(IncludableGzipFilter.this._minGzipSize); } @Override - protected CompressedStream newCompressedStream(HttpServletRequest request, HttpServletResponse response, long contentLength, int bufferSize, - int minGzipSize) throws IOException + public void setHeader(String name,String value) { - String encodingHeader = request.getHeader("accept-encoding"); - CompressionType compressionType = CompressionType.getByEncodingHeader(encodingHeader); - if (compressionType.equals(CompressionType.GZIP)) - { - return new IncludableGzipStream(request,response,contentLength,bufferSize,minGzipSize); - } - else if (compressionType.equals(CompressionType.DEFLATE)) - { - return new IncludableDeflateStream(request,response,contentLength,bufferSize,minGzipSize); - } - else - { - throw new IllegalStateException(compressionType.name() + " not supported."); - } + super.setHeader(name,value); + HttpServletResponse response = (HttpServletResponse)getResponse(); + if (!response.containsHeader(name)) + response.setHeader("org.eclipse.jetty.server.include."+name,value);; } - @Override protected PrintWriter newWriter(OutputStream out, String encoding) throws UnsupportedEncodingException { @@ -104,52 +134,4 @@ public class IncludableGzipFilter extends GzipFilter } } - public class IncludableGzipStream extends GzipStreamImpl - { - public IncludableGzipStream(HttpServletRequest request, HttpServletResponse response, long contentLength, int bufferSize, int minGzipSize) - throws IOException - { - super(request,response,contentLength,bufferSize,minGzipSize); - } - - @Override - protected boolean setContentEncoding() - { - if (_request.getAttribute("javax.servlet.include.request_uri") != null) - { - _response.setHeader("org.eclipse.jetty.server.include.Content-Encoding","gzip"); - } - else - { - _response.setHeader("Content-Encoding","gzip"); - } - - return _response.containsHeader("Content-Encoding"); - } - } - - public class IncludableDeflateStream extends DeflateStreamImpl - { - public IncludableDeflateStream(HttpServletRequest request, HttpServletResponse response, long contentLength, int bufferSize, int minGzipSize) - throws IOException - { - super(request,response,contentLength,bufferSize,minGzipSize); - } - - @Override - protected boolean setContentEncoding() - { - if (_request.getAttribute("javax.servlet.include.request_uri") != null) - { - _response.setHeader("org.eclipse.jetty.server.include.Content-Encoding","deflate"); - } - else - { - _response.setHeader("Content-Encoding","deflate"); - } - - return _response.containsHeader("Content-Encoding"); - } - } - } diff --git a/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/GzipFilterContentLengthTest.java b/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/GzipFilterContentLengthTest.java index b636583c716..c752591bc25 100644 --- a/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/GzipFilterContentLengthTest.java +++ b/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/GzipFilterContentLengthTest.java @@ -6,8 +6,7 @@ import java.util.List; import javax.servlet.Servlet; import org.eclipse.jetty.http.HttpStatus; -import org.eclipse.jetty.http.gzip.CompressionType; -import org.eclipse.jetty.http.gzip.GzipResponseWrapperImpl; +import org.eclipse.jetty.http.gzip.CompressedResponseWrapper; import org.eclipse.jetty.servlet.FilterHolder; import org.eclipse.jetty.servlets.gzip.GzipTester; import org.eclipse.jetty.servlets.gzip.TestServletLengthStreamTypeWrite; @@ -49,29 +48,29 @@ public class GzipFilterContentLengthTest { return Arrays.asList(new Object[][] { - { TestServletLengthStreamTypeWrite.class, CompressionType.GZIP }, - { TestServletLengthTypeStreamWrite.class, CompressionType.GZIP }, - { TestServletStreamLengthTypeWrite.class, CompressionType.GZIP }, - { TestServletStreamTypeLengthWrite.class, CompressionType.GZIP }, - { TestServletTypeLengthStreamWrite.class, CompressionType.GZIP }, - { TestServletTypeStreamLengthWrite.class, CompressionType.GZIP }, - { TestServletLengthStreamTypeWrite.class, CompressionType.DEFLATE }, - { TestServletLengthTypeStreamWrite.class, CompressionType.DEFLATE }, - { TestServletStreamLengthTypeWrite.class, CompressionType.DEFLATE }, - { TestServletStreamTypeLengthWrite.class, CompressionType.DEFLATE }, - { TestServletTypeLengthStreamWrite.class, CompressionType.DEFLATE }, - { TestServletTypeStreamLengthWrite.class, CompressionType.DEFLATE } + { TestServletLengthStreamTypeWrite.class, GzipFilter.GZIP }, + { TestServletLengthTypeStreamWrite.class, GzipFilter.GZIP }, + { TestServletStreamLengthTypeWrite.class, GzipFilter.GZIP }, + { TestServletStreamTypeLengthWrite.class, GzipFilter.GZIP }, + { TestServletTypeLengthStreamWrite.class, GzipFilter.GZIP }, + { TestServletTypeStreamLengthWrite.class, GzipFilter.GZIP }, + { TestServletLengthStreamTypeWrite.class, GzipFilter.DEFLATE }, + { TestServletLengthTypeStreamWrite.class, GzipFilter.DEFLATE }, + { TestServletStreamLengthTypeWrite.class, GzipFilter.DEFLATE }, + { TestServletStreamTypeLengthWrite.class, GzipFilter.DEFLATE }, + { TestServletTypeLengthStreamWrite.class, GzipFilter.DEFLATE }, + { TestServletTypeStreamLengthWrite.class, GzipFilter.DEFLATE } }); } - private static final int LARGE = GzipResponseWrapperImpl.DEFAULT_BUFFER_SIZE * 8; - private static final int MEDIUM = GzipResponseWrapperImpl.DEFAULT_BUFFER_SIZE; - private static final int SMALL = GzipResponseWrapperImpl.DEFAULT_BUFFER_SIZE / 4; - private static final int TINY = GzipResponseWrapperImpl.DEFAULT_MIN_COMPRESS_SIZE/ 2; + private static final int LARGE = CompressedResponseWrapper.DEFAULT_BUFFER_SIZE * 8; + private static final int MEDIUM = CompressedResponseWrapper.DEFAULT_BUFFER_SIZE; + private static final int SMALL = CompressedResponseWrapper.DEFAULT_BUFFER_SIZE / 4; + private static final int TINY = CompressedResponseWrapper.DEFAULT_MIN_COMPRESS_SIZE/ 2; - private CompressionType compressionType; + private String compressionType; - public GzipFilterContentLengthTest(Class<? extends Servlet> testServlet, CompressionType compressionType) + public GzipFilterContentLengthTest(Class<? extends Servlet> testServlet, String compressionType) { this.testServlet = testServlet; this.compressionType = compressionType; diff --git a/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/GzipFilterDefaultNoRecompressTest.java b/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/GzipFilterDefaultNoRecompressTest.java index 996e26a0547..a890b96b628 100644 --- a/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/GzipFilterDefaultNoRecompressTest.java +++ b/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/GzipFilterDefaultNoRecompressTest.java @@ -5,7 +5,6 @@ import java.io.IOException; import java.util.Arrays; import java.util.List; -import org.eclipse.jetty.http.gzip.CompressionType; import org.eclipse.jetty.servlet.DefaultServlet; import org.eclipse.jetty.servlet.FilterHolder; import org.eclipse.jetty.servlets.gzip.GzipTester; @@ -32,41 +31,41 @@ public class GzipFilterDefaultNoRecompressTest return Arrays.asList(new Object[][] { // Some already compressed files - { "test_quotes.gz", "application/gzip", CompressionType.GZIP }, - { "test_quotes.bz2", "application/bzip2", CompressionType.GZIP }, - { "test_quotes.zip", "application/zip", CompressionType.GZIP }, - { "test_quotes.rar", "application/octet-stream", CompressionType.GZIP }, + { "test_quotes.gz", "application/gzip", GzipFilter.GZIP }, + { "test_quotes.bz2", "application/bzip2", GzipFilter.GZIP }, + { "test_quotes.zip", "application/zip", GzipFilter.GZIP }, + { "test_quotes.rar", "application/octet-stream", GzipFilter.GZIP }, // Some images (common first) - { "jetty_logo.png", "image/png", CompressionType.GZIP }, - { "jetty_logo.gif", "image/gif", CompressionType.GZIP }, - { "jetty_logo.jpeg", "image/jpeg", CompressionType.GZIP }, - { "jetty_logo.jpg", "image/jpeg", CompressionType.GZIP }, + { "jetty_logo.png", "image/png", GzipFilter.GZIP }, + { "jetty_logo.gif", "image/gif", GzipFilter.GZIP }, + { "jetty_logo.jpeg", "image/jpeg", GzipFilter.GZIP }, + { "jetty_logo.jpg", "image/jpeg", GzipFilter.GZIP }, // Lesser encountered images (usually found being requested from non-browser clients) - { "jetty_logo.bmp", "image/bmp", CompressionType.GZIP }, - { "jetty_logo.tga", "application/tga", CompressionType.GZIP }, - { "jetty_logo.tif", "image/tiff", CompressionType.GZIP }, - { "jetty_logo.tiff", "image/tiff", CompressionType.GZIP }, - { "jetty_logo.xcf", "image/xcf", CompressionType.GZIP }, - { "jetty_logo.jp2", "image/jpeg2000", CompressionType.GZIP }, + { "jetty_logo.bmp", "image/bmp", GzipFilter.GZIP }, + { "jetty_logo.tga", "application/tga", GzipFilter.GZIP }, + { "jetty_logo.tif", "image/tiff", GzipFilter.GZIP }, + { "jetty_logo.tiff", "image/tiff", GzipFilter.GZIP }, + { "jetty_logo.xcf", "image/xcf", GzipFilter.GZIP }, + { "jetty_logo.jp2", "image/jpeg2000", GzipFilter.GZIP }, // Same tests again for deflate // Some already compressed files - { "test_quotes.gz", "application/gzip", CompressionType.DEFLATE }, - { "test_quotes.bz2", "application/bzip2", CompressionType.DEFLATE }, - { "test_quotes.zip", "application/zip", CompressionType.DEFLATE }, - { "test_quotes.rar", "application/octet-stream", CompressionType.DEFLATE }, + { "test_quotes.gz", "application/gzip", GzipFilter.DEFLATE }, + { "test_quotes.bz2", "application/bzip2", GzipFilter.DEFLATE }, + { "test_quotes.zip", "application/zip", GzipFilter.DEFLATE }, + { "test_quotes.rar", "application/octet-stream", GzipFilter.DEFLATE }, // Some images (common first) - { "jetty_logo.png", "image/png", CompressionType.DEFLATE }, - { "jetty_logo.gif", "image/gif", CompressionType.DEFLATE }, - { "jetty_logo.jpeg", "image/jpeg", CompressionType.DEFLATE }, - { "jetty_logo.jpg", "image/jpeg", CompressionType.DEFLATE }, + { "jetty_logo.png", "image/png", GzipFilter.DEFLATE }, + { "jetty_logo.gif", "image/gif", GzipFilter.DEFLATE }, + { "jetty_logo.jpeg", "image/jpeg", GzipFilter.DEFLATE }, + { "jetty_logo.jpg", "image/jpeg", GzipFilter.DEFLATE }, // Lesser encountered images (usually found being requested from non-browser clients) - { "jetty_logo.bmp", "image/bmp", CompressionType.DEFLATE }, - { "jetty_logo.tga", "application/tga", CompressionType.DEFLATE }, - { "jetty_logo.tif", "image/tiff", CompressionType.DEFLATE }, - { "jetty_logo.tiff", "image/tiff", CompressionType.DEFLATE }, - { "jetty_logo.xcf", "image/xcf", CompressionType.DEFLATE }, - { "jetty_logo.jp2", "image/jpeg2000", CompressionType.DEFLATE } }); + { "jetty_logo.bmp", "image/bmp", GzipFilter.DEFLATE }, + { "jetty_logo.tga", "application/tga", GzipFilter.DEFLATE }, + { "jetty_logo.tif", "image/tiff", GzipFilter.DEFLATE }, + { "jetty_logo.tiff", "image/tiff", GzipFilter.DEFLATE }, + { "jetty_logo.xcf", "image/xcf", GzipFilter.DEFLATE }, + { "jetty_logo.jp2", "image/jpeg2000", GzipFilter.DEFLATE } }); } @Rule @@ -74,9 +73,9 @@ public class GzipFilterDefaultNoRecompressTest private String alreadyCompressedFilename; private String expectedContentType; - private CompressionType compressionType; + private String compressionType; - public GzipFilterDefaultNoRecompressTest(String testFilename, String expectedContentType, CompressionType compressionType) + public GzipFilterDefaultNoRecompressTest(String testFilename, String expectedContentType, String compressionType) { this.alreadyCompressedFilename = testFilename; this.expectedContentType = expectedContentType; diff --git a/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/GzipFilterDefaultTest.java b/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/GzipFilterDefaultTest.java index 47f637150cd..6c6faba5198 100644 --- a/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/GzipFilterDefaultTest.java +++ b/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/GzipFilterDefaultTest.java @@ -10,8 +10,7 @@ import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.eclipse.jetty.http.HttpStatus; -import org.eclipse.jetty.http.gzip.CompressionType; -import org.eclipse.jetty.http.gzip.GzipResponseWrapperImpl; +import org.eclipse.jetty.http.gzip.CompressedResponseWrapper; import org.eclipse.jetty.servlet.DefaultServlet; import org.eclipse.jetty.servlet.FilterHolder; import org.eclipse.jetty.servlets.gzip.GzipTester; @@ -29,20 +28,20 @@ import org.junit.runners.Parameterized.Parameters; public class GzipFilterDefaultTest { @Parameters - public static Collection<CompressionType[]> data() + public static Collection<String[]> data() { - CompressionType[][] data = new CompressionType[][] + String[][] data = new String[][] { - { CompressionType.GZIP }, - { CompressionType.DEFLATE } + { GzipFilter.GZIP }, + { GzipFilter.DEFLATE } }; return Arrays.asList(data); } - private CompressionType compressionType; + private String compressionType; - public GzipFilterDefaultTest(CompressionType compressionType) + public GzipFilterDefaultTest(String compressionType) { this.compressionType = compressionType; } @@ -80,7 +79,7 @@ public class GzipFilterDefaultTest GzipTester tester = new GzipTester(testingdir, compressionType); // Test content that is smaller than the buffer. - int filesize = GzipResponseWrapperImpl.DEFAULT_BUFFER_SIZE / 4; + int filesize = CompressedResponseWrapper.DEFAULT_BUFFER_SIZE / 4; tester.prepareServerFile("file.txt",filesize); FilterHolder holder = tester.setContentServlet(org.eclipse.jetty.servlet.DefaultServlet.class); @@ -103,7 +102,7 @@ public class GzipFilterDefaultTest GzipTester tester = new GzipTester(testingdir, compressionType); // Test content that is smaller than the buffer. - int filesize = GzipResponseWrapperImpl.DEFAULT_BUFFER_SIZE * 4; + int filesize = CompressedResponseWrapper.DEFAULT_BUFFER_SIZE * 4; tester.prepareServerFile("file.txt",filesize); FilterHolder holder = tester.setContentServlet(org.eclipse.jetty.servlet.DefaultServlet.class); @@ -126,7 +125,7 @@ public class GzipFilterDefaultTest GzipTester tester = new GzipTester(testingdir, compressionType); // Test content that is smaller than the buffer. - int filesize = GzipResponseWrapperImpl.DEFAULT_BUFFER_SIZE * 4; + int filesize = CompressedResponseWrapper.DEFAULT_BUFFER_SIZE * 4; tester.prepareServerFile("file.mp3",filesize); FilterHolder holder = tester.setContentServlet(org.eclipse.jetty.servlet.DefaultServlet.class); @@ -173,7 +172,7 @@ public class GzipFilterDefaultTest holder.setInitParameter("excludedAgents", "foo"); tester.setUserAgent("foo"); - int filesize = GzipResponseWrapperImpl.DEFAULT_BUFFER_SIZE * 4; + int filesize = CompressedResponseWrapper.DEFAULT_BUFFER_SIZE * 4; tester.prepareServerFile("file.txt",filesize); try diff --git a/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/GzipWithPipeliningTest.java b/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/GzipWithPipeliningTest.java index 65a66898fc4..4144b0702d1 100644 --- a/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/GzipWithPipeliningTest.java +++ b/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/GzipWithPipeliningTest.java @@ -18,7 +18,6 @@ import java.util.regex.Pattern; import java.util.zip.GZIPInputStream; import java.util.zip.InflaterInputStream; -import org.eclipse.jetty.http.gzip.CompressionType; import org.eclipse.jetty.server.Connector; import org.eclipse.jetty.server.Server; import org.eclipse.jetty.servlet.DefaultServlet; @@ -50,10 +49,10 @@ public class GzipWithPipeliningTest // Test different Content-Encoding header combinations. So implicitly testing that gzip is preferred oder deflate String[][] data = new String[][] { - { CompressionType.GZIP.getEncodingHeader() }, - { CompressionType.DEFLATE.getEncodingHeader() + ", " + CompressionType.GZIP.getEncodingHeader() }, - { CompressionType.GZIP.getEncodingHeader() + ", " + CompressionType.DEFLATE.getEncodingHeader() }, - { CompressionType.DEFLATE.getEncodingHeader() } + { GzipFilter.GZIP }, + { GzipFilter.DEFLATE + ", " + GzipFilter.GZIP }, + { GzipFilter.GZIP + ", " + GzipFilter.DEFLATE }, + { GzipFilter.DEFLATE } }; return Arrays.asList(data); @@ -137,7 +136,7 @@ public class GzipWithPipeliningTest respHeader = client.readResponseHeader(); System.out.println("Response Header #1 --\n" + respHeader); - String expectedEncodingHeader = encodingHeader.equals(CompressionType.DEFLATE.getEncodingHeader()) ? CompressionType.DEFLATE.getEncodingHeader() : CompressionType.GZIP.getEncodingHeader(); + String expectedEncodingHeader = encodingHeader.equals(GzipFilter.DEFLATE) ? GzipFilter.DEFLATE : GzipFilter.GZIP; assertThat("Content-Encoding should be gzipped",respHeader,containsString("Content-Encoding: " + expectedEncodingHeader + "\r\n")); assertThat("Transfer-Encoding should be chunked",respHeader,containsString("Transfer-Encoding: chunked\r\n")); @@ -182,7 +181,7 @@ public class GzipWithPipeliningTest IO.close(rawOutputStream); FileInputStream rawInputStream = new FileInputStream(rawOutputFile); InputStream uncompressedStream = null; - if (CompressionType.DEFLATE.getEncodingHeader().equals(encodingHeader)) + if (GzipFilter.DEFLATE.equals(encodingHeader)) { uncompressedStream = new InflaterInputStream(rawInputStream); } diff --git a/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/IncludableGzipFilterMinSizeTest.java b/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/IncludableGzipFilterMinSizeTest.java index e12abff667a..6d37b0f1e6d 100644 --- a/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/IncludableGzipFilterMinSizeTest.java +++ b/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/IncludableGzipFilterMinSizeTest.java @@ -18,7 +18,6 @@ import java.util.Collection; import javax.servlet.Servlet; -import org.eclipse.jetty.http.gzip.CompressionType; import org.eclipse.jetty.servlet.FilterHolder; import org.eclipse.jetty.servlets.gzip.GzipTester; import org.eclipse.jetty.servlets.gzip.TestMinGzipSizeServlet; @@ -39,18 +38,18 @@ import org.junit.runners.Parameterized.Parameters; public class IncludableGzipFilterMinSizeTest { @Parameters - public static Collection<CompressionType[]> data() + public static Collection<String[]> data() { - CompressionType[][] data = new CompressionType[][] + String[][] data = new String[][] { - { CompressionType.GZIP }, - { CompressionType.DEFLATE } + { GzipFilter.GZIP }, + { GzipFilter.DEFLATE } }; return Arrays.asList(data); } - public IncludableGzipFilterMinSizeTest(CompressionType compressionType) + public IncludableGzipFilterMinSizeTest(String compressionType) { this.compressionType = compressionType; } @@ -58,7 +57,7 @@ public class IncludableGzipFilterMinSizeTest @Rule public TestingDir testdir = new TestingDir(); - private CompressionType compressionType; + private String compressionType; private Class<? extends Servlet> testServlet = TestMinGzipSizeServlet.class; @Test diff --git a/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/IncludableGzipFilterTest.java b/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/IncludableGzipFilterTest.java index 49459e4e2ef..9872c198014 100644 --- a/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/IncludableGzipFilterTest.java +++ b/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/IncludableGzipFilterTest.java @@ -29,7 +29,6 @@ import java.util.zip.InflaterInputStream; import javax.servlet.http.HttpServletResponse; -import org.eclipse.jetty.http.gzip.CompressionType; import org.eclipse.jetty.io.ByteArrayBuffer; import org.eclipse.jetty.servlet.FilterHolder; import org.eclipse.jetty.testing.HttpTester; @@ -48,12 +47,12 @@ import org.junit.runners.Parameterized.Parameters; public class IncludableGzipFilterTest { @Parameters - public static Collection<CompressionType[]> data() + public static Collection<String[]> data() { - CompressionType[][] data = new CompressionType[][] + String[][] data = new String[][] { - { CompressionType.GZIP }, - { CompressionType.DEFLATE } + { GzipFilter.GZIP }, + { GzipFilter.DEFLATE } }; return Arrays.asList(data); @@ -77,9 +76,9 @@ public class IncludableGzipFilterTest "et cursus magna. Donec orci enim, molestie a lobortis eu, imperdiet vitae neque."; private ServletTester tester; - private CompressionType compressionType; + private String compressionType; - public IncludableGzipFilterTest(CompressionType compressionType) + public IncludableGzipFilterTest(String compressionType) { this.compressionType = compressionType; } @@ -121,7 +120,7 @@ public class IncludableGzipFilterTest request.setMethod("GET"); request.setVersion("HTTP/1.0"); request.setHeader("Host","tester"); - request.setHeader("accept-encoding", compressionType.getEncodingHeader()); + request.setHeader("accept-encoding", compressionType); request.setURI("/context/file.txt"); ByteArrayBuffer reqsBuff = new ByteArrayBuffer(request.generate().getBytes()); @@ -129,16 +128,16 @@ public class IncludableGzipFilterTest response.parse(respBuff.asArray()); assertTrue(response.getMethod()==null); - assertTrue(response.getHeader("Content-Encoding").equalsIgnoreCase(compressionType.getEncodingHeader())); + assertTrue(response.getHeader("Content-Encoding").equalsIgnoreCase(compressionType)); assertEquals(HttpServletResponse.SC_OK,response.getStatus()); InputStream testIn = null; ByteArrayInputStream compressedResponseStream = new ByteArrayInputStream(response.getContentBytes()); - if (compressionType.equals(CompressionType.GZIP)) + if (compressionType.equals(GzipFilter.GZIP)) { testIn = new GZIPInputStream(compressedResponseStream); } - else if (compressionType.equals(CompressionType.DEFLATE)) + else if (compressionType.equals(GzipFilter.DEFLATE)) { testIn = new InflaterInputStream(compressedResponseStream); } diff --git a/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/gzip/GzipTester.java b/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/gzip/GzipTester.java index 91cc374c893..36cec8037b9 100644 --- a/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/gzip/GzipTester.java +++ b/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/gzip/GzipTester.java @@ -25,7 +25,6 @@ import java.util.zip.InflaterInputStream; import javax.servlet.Servlet; import javax.servlet.http.HttpServletResponse; -import org.eclipse.jetty.http.gzip.CompressionType; import org.eclipse.jetty.io.ByteArrayBuffer; import org.eclipse.jetty.servlet.FilterHolder; import org.eclipse.jetty.servlet.ServletHolder; @@ -44,9 +43,9 @@ public class GzipTester private String userAgent = null; private ServletTester servletTester; private TestingDir testdir; - private CompressionType compressionType; + private String compressionType; - public GzipTester(TestingDir testingdir, CompressionType compressionType) + public GzipTester(TestingDir testingdir, String compressionType) { this.testdir = testingdir; this.compressionType = compressionType; @@ -68,7 +67,7 @@ public class GzipTester request.setMethod("GET"); request.setVersion("HTTP/1.0"); request.setHeader("Host","tester"); - request.setHeader("Accept-Encoding",compressionType.getEncodingHeader()); + request.setHeader("Accept-Encoding",compressionType); if (this.userAgent != null) request.setHeader("User-Agent", this.userAgent); request.setURI("/context/" + requestedFilename); @@ -83,7 +82,7 @@ public class GzipTester Assert.assertThat("Response.method",response.getMethod(),nullValue()); Assert.assertThat("Response.status",response.getStatus(),is(HttpServletResponse.SC_OK)); Assert.assertThat("Response.header[Content-Length]",response.getHeader("Content-Length"),notNullValue()); - Assert.assertThat("Response.header[Content-Encoding]",response.getHeader("Content-Encoding"),containsString(compressionType.getEncodingHeader())); + Assert.assertThat("Response.header[Content-Encoding]",response.getHeader("Content-Encoding"),containsString(compressionType)); // Assert that the decompressed contents are what we expect. File serverFile = testdir.getFile(serverFilename); @@ -96,11 +95,11 @@ public class GzipTester try { bais = new ByteArrayInputStream(response.getContentBytes()); - if (compressionType.equals(CompressionType.GZIP)) + if (compressionType.equals(GzipFilter.GZIP)) { in = new GZIPInputStream(bais); } - else if (compressionType.equals(CompressionType.DEFLATE)) + else if (compressionType.equals(GzipFilter.DEFLATE)) { in = new InflaterInputStream(bais); } @@ -142,7 +141,7 @@ public class GzipTester request.setMethod("GET"); request.setVersion("HTTP/1.0"); request.setHeader("Host","tester"); - request.setHeader("Accept-Encoding",compressionType.getEncodingHeader()); + request.setHeader("Accept-Encoding",compressionType); if (this.userAgent != null) request.setHeader("User-Agent", this.userAgent); request.setURI("/context/" + requestedFilename); @@ -229,7 +228,7 @@ public class GzipTester request.setMethod("GET"); request.setVersion("HTTP/1.0"); request.setHeader("Host","tester"); - request.setHeader("Accept-Encoding",compressionType.getEncodingHeader()); + request.setHeader("Accept-Encoding",compressionType); if (this.userAgent != null) request.setHeader("User-Agent", this.userAgent); if (filename == null) @@ -252,7 +251,7 @@ public class GzipTester int serverLength = Integer.parseInt(response.getHeader("Content-Length")); Assert.assertThat("Response.header[Content-Length]",serverLength,is(expectedFilesize)); } - Assert.assertThat("Response.header[Content-Encoding]",response.getHeader("Content-Encoding"),not(containsString(compressionType.getEncodingHeader()))); + Assert.assertThat("Response.header[Content-Encoding]",response.getHeader("Content-Encoding"),not(containsString(compressionType))); // Assert that the contents are what we expect. if (filename != null)