retrofit + okhttp : Retrieve GZIPInputStream

Question

I have a problem when i activate gzip on WS using retrofit 1.4.1 and okhttp 1.3.0.

RequestInterceptor requestInterceptor = new RequestInterceptor() {
            @Override
            public void intercept(RequestFacade request) {
                request.addHeader("content-type", "application/json");
                request.addHeader("accept-encoding", "gzip");  // Here is the problem
            }
        }; 
RestAdapter restAdapter = new RestAdapter.Builder()
            .setEndpoint(Constants.HOST)
            .setLogLevel(RestAdapter.LogLevel.FULL)
            .setRequestInterceptor(requestInterceptor)
            .build();

If I comment the following line request.addHeader("accept-encoding", "gzip"); there is no problem but if gzip is activated, i get an error (my request falls in failure).

Here is my logcat with request.addHeader("accept-encoding", "gzip");

1326               Retrofit  D  : HTTP/1.1 200 OK
  1326               Retrofit  D  Cache-Control: public, max-age=600
  1326               Retrofit  D  Content-Encoding: gzip
  1326               Retrofit  D  Content-Length: 254
  1326               Retrofit  D  Content-Type: application/json
  1326               Retrofit  D  Date: Wed, 05 Feb 2014 20:22:26 GMT
  1326               Retrofit  D  OkHttp-Received-Millis: 1391631746193
  1326               Retrofit  D  OkHttp-Response-Source: NETWORK 200
  1326               Retrofit  D  OkHttp-Selected-Transport: http/1.1
  1326               Retrofit  D  OkHttp-Sent-Millis: 1391631745971
  1326               Retrofit  D  Server: Apache
  1326               Retrofit  D  Vary: Accept-Encoding
  1326               Retrofit  D  X-Powered-By: PHP/5.3.3-7+squeeze18
  1326               Retrofit  D  ������������}�?O�0��~����nHZOH0 �D�ù���?���~w.�:����=�{�
                               ����|A���=�V/~}o�)���&����<�`�6&��ѳ:��5�ke��V�WD�H�
                               ���ud�J5رyp��G�ːg�y�ʴ����Mxq<�#�Rb`Su�@�0��y��lr;�W�2�C3�
                               T��$���.�
                                          ��xѥ���R
                                                   y���hmt����R����o����v��7@P�
                               4Y����
  1326               Retrofit  D  <--- END HTTP (254-byte body)
  1326             System.err  W  retrofit.RetrofitError: retrofit.converter.ConversionException: com.google.gson.JsonSyntaxException: java.lang.Ille
                               galStateException: Expected BEGIN_OBJECT but was STRING at line 1 column 1
  1326             System.err  W  at retrofit.RestAdapter$RestHandler.invokeRequest(RestAdapter.java:408)
  1326             System.err  W  at retrofit.RestAdapter$RestHandler.access$100(RestAdapter.java:262)
  1326             System.err  W  at retrofit.RestAdapter$RestHandler$2.obtainResponse(RestAdapter.java:313)
  1326             System.err  W  at retrofit.CallbackRunnable.run(CallbackRunnable.java:38)
  1326             System.err  W  at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1080)
  1326             System.err  W  at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:573)
  1326             System.err  W  at retrofit.Platform$Android$2$1.run(Platform.java:136)
  1326             System.err  W  at java.lang.Thread.run(Thread.java:841)
  1326             System.err  W  Caused by: retrofit.converter.ConversionException: com.google.gson.JsonSyntaxException: java.lang.IllegalStateExcep

How can I turn on gzip ?

Thx in advance

Answer 1

Just omit the accept-encoding header from your code. OkHttp will add its own accept-encoding header, and if the server responds with gzip then OkHttp will silently unzip it for you.

Answer 2

After running into a similar issue (in my case, without adding any Accept-Encoding header, it would occasionally fail to un-gzip the response, leaving also the Content-Encoding: gzip header in it, crashing the JSON parser), and with no clear way around this, I manually enabled gzip for Retrofit by creating the delegated Client implementation below. It works great, except that you probably should not use it for very large (e.g. > 250KB) responses, as they are first copied into a byte array.

public class GzippedClient implements Client {

    private Client wrappedClient;

    public GzippedClient(Client wrappedClient) {
        this.wrappedClient = wrappedClient;
    }

    @Override
    public Response execute(Request request) throws IOException {
        Response response = wrappedClient.execute(request);

        boolean gzipped = false;
        for (Header h : response.getHeaders()) {
            if (h.getName() != null && h.getName().toLowerCase().equals("content-encoding") && h.getValue() != null && h.getValue().toLowerCase().equals("gzip")) {
                gzipped = true;
                break;
            }
        }

        Response r = null;
        if (gzipped) {
            InputStream is = null;
            ByteArrayOutputStream bos = null;

            try {
                is = new BufferedInputStream(new GZIPInputStream(response.getBody().in()));
                bos = new ByteArrayOutputStream();

                int b;
                while ((b = is.read()) != -1) {
                    bos.write(b);
                }

                TypedByteArray body = new TypedByteArray(response.getBody().mimeType(), bos.toByteArray());
                r = new Response(response.getUrl(), response.getStatus(), response.getReason(), response.getHeaders(), body);
            } finally {
                if (is != null) {
                    is.close();
                }
                if (bos != null) {
                    bos.close();
                }
            }
        } else {
            r = response;
        }
        return r;
    }

}

You will also have to add an Accept-Encoding header to your requests, e.g. by using a RequestInterceptor

requestFacade.addHeader("Accept-Encoding", "gzip");

Finally, you have to wrap your existing Client into this new GzippedClient, like so:

restBuilder.setClient(new GzippedClient(new OkClient(okHttpClient)));

That's it. Now your data will be gzipped.

EDIT: It seems that in OkHttp version 1.5.1, a bug (https://github.com/square/okhttp/pull/632) seems to have been fixed related to the transparent gzipping which may (or may not) have been the source of my initial issue. If so, the occasional failure to un-gzip may no longer occur, though it happened rarely enough that I cannot confirm this yet. Either way, if you want to rely on your own, rather than the transparent adding/removing of headers and gzipping, then the solution described will work.

Answer 3

If you check HttpEngine in OkHttp library, then you can find below code, which means if you manually add "Accept-Encoding":"gzip" header into request, then un-zip is your responsibility. /** * True if this client added an "Accept-Encoding: gzip" header field and is * therefore responsible for also decompressing the transfer stream. */ private boolean transparentGzip;

so if you manually add "Accept-Encoding":"gzip" header, then after getting response, do un-zip like below.

private static String readContentFromTypedInput(TypedInput typedInput){

        InputStreamReader isr = null;
        BufferedReader br = null;
        char[] cbuf = new char[512];
        StringWriter stringWriter = new StringWriter();

        try {
            final InputStream in = typedInput.in();
            boolean isGzipped = GZipper.isGzippped(in);
            if(isGzipped){
                return new String(GZipper.doUnZip(in));
            }
            isr = new InputStreamReader(in);
            br = new BufferedReader(isr);
            while((br.read(cbuf))!= -1){
                stringWriter.write(cbuf);
            }
        } catch (IOException e) {
            throw new InvalidTestCaseException("failed read received content.", e);
        } finally{
            try{
                if(br != null) br.close();
            }catch(IOException e){ 
                //ignore
            }
        }
        return stringWriter.toString().trim();
    }

GZipper.java

public class GZipper{

public static final String DEFAULT_CHARSET = "utf-8";
private static final int BYTE_BLOCK_LENGTH = 1024;

public static byte[] doZip(final String message){
    if(message == null || message.isEmpty()){
        throw new SystemFailedException("Fail to zip - given message is null or empty");
    }
    byte[] gzippped = null;
    try {
        gzippped = doZip(message.getBytes(DEFAULT_CHARSET));
    } catch (Throwable e) {
        throw new SystemFailedException(e.getMessage(), e);
    }
    return gzippped;
}

public static byte[] doZip(final byte[] unzippedMessageByte){
    validate(unzippedMessageByte, "Fail to zip - given bytes is null or empty");

    ByteArrayInputStream is = null;
    ByteArrayOutputStream bos = null;
    GZIPOutputStream gzip_os = null;
    byte[] compressedBytes = null;
    try{
        is = new ByteArrayInputStream(unzippedMessageByte);
        bos = new ByteArrayOutputStream();
        gzip_os = new GZIPOutputStream(bos);
        copy(is, gzip_os);
        gzip_os.finish();
        compressedBytes = bos.toByteArray();
    }catch(IOException e){
        throw new SystemFailedException(e.getMessage(), e);
    }finally{
        try{
            if(is != null){is.close();}
            if(gzip_os != null){gzip_os.close();}
            if(bos != null){bos.close();}
        }catch(IOException e){
            //ignore
        }
    }
    return compressedBytes;
}

public static String doUnZipToString(final byte[] gzippedMessage){
    validate(gzippedMessage, "Fail to unzip - given bytes is null or empty");
    byte[] gzippped = null;
    String unzippedMessage = null;
    try {
        gzippped = doUnZip(gzippedMessage);
        unzippedMessage = new String(gzippped, DEFAULT_CHARSET);
    } catch (Throwable e) {
        throw new SystemFailedException(e.getMessage(), e);
    }
    return unzippedMessage;
}

private static void validate(final byte[] bytes, String failedMessage) {
    if(bytes == null || bytes.length == 0){
        throw new SystemFailedException(failedMessage);
    }
}

public static byte[] doUnZip(InputStream in) {
    if(!(in instanceof ByteArrayInputStream)){
        try {
            return doUnZip(IOUtils.toByteArray(in));
        } catch (IOException e) {
            throw new SystemFailedException(e.getMessage(), e);
        }
    }

     ByteArrayOutputStream bos = null;
     InputStream gzip_is = null;
     byte[] bytes = null;
    try{
        bos = new ByteArrayOutputStream();
        gzip_is = new GZIPInputStream(in);
        copy(gzip_is,bos);
        bytes = bos.toByteArray();
    }catch(IOException e){
        throw new SystemFailedException(e.getMessage(), e);
    }finally{
        try{
            if(gzip_is != null) gzip_is.close();
            if(bos != null) bos.close();
        }catch(IOException e){
            //ignore
        }
    }
    return bytes;
}

public static byte[] doUnZip(final byte[] zippedMessage){
    validate(zippedMessage, "Fail to unzip - given bytes is null or empty");
    ByteArrayInputStream is = null;
    try{
        is = new ByteArrayInputStream(zippedMessage);
        return doUnZip(is);
    }finally{
        try{
            if(is != null) is.close();
        }catch(IOException e){
            //ignore
        }
    }
}

public static String doUnZip(File file){
    validate(file);

    GZIPInputStream gzipInputStream = null;
    StringWriter writer = null;
    String result = "";

    try{
        byte[] buffer = new byte[BYTE_BLOCK_LENGTH];
        gzipInputStream = new GZIPInputStream(new FileInputStream(file));
        writer = new StringWriter();
        while((gzipInputStream.read(buffer)) > 0){
            writer.write(new String(buffer));
            writer.flush();
        }
        result = writer.toString();
    }catch(IOException e){
        //do something to handle exception
    }
    finally{
        try{
            if(writer != null){writer.close();}
            if(gzipInputStream != null){gzipInputStream.close();}
        }catch(IOException e){
            //ignore
        }
    }
    return result;
}

private static void validate(File file) {
    if(file==null || !file.exists()){
        throw new SystemFailedException("Fail to unzip - file is not exist");
    }
}

private static void copy(InputStream in, OutputStream out)throws IOException {
    byte[] buf = new byte[BYTE_BLOCK_LENGTH];
    int len = -1;
    while ((len = in.read(buf, 0, buf.length)) != -1) {
        out.write(buf, 0, len);
    }
}

public static boolean isGzipped(byte[] input){
    return isGzippped(new ByteArrayInputStream(input));
}

public static boolean isGzippped(InputStream in){
    boolean markSupported = in.markSupported();
    boolean result = false;
    try {
        if(markSupported){
            in.mark(0);
            result = (readUShort(in) == GZIPInputStream.GZIP_MAGIC);
            in.reset();
        }
    } catch (Exception e) {
        result = false;
    }
    return result;
}

private static int readUShort(InputStream in) throws IOException {
    int b = readUByte(in);
    return ((int)readUByte(in) << 8) | b;
}

/*
 * Reads unsigned byte.
 */
private static int readUByte(InputStream in) throws IOException {
    int b = in.read();
    if (b == -1) {
        throw new EOFException();
    }
    if (b < -1 || b > 255) {
       b = 0;
    }
    return b;
}

}