Don't use chunked encoding in BatchingHttpInterceptor

[BoD]

Description

In BatchingHttpInterceptor the length of the body is not computed and set to -1, which results in chunked encoding with OkHttp, which is not supported by some servers.

[BoD]

In the meantime, this can be achieved with an http interceptor:

class ContentLengthHttpInterceptor : HttpInterceptor {
    override suspend fun intercept(request: HttpRequest, chain: HttpInterceptorChain): HttpResponse {
        val requestBuffer = Buffer()
        request.body!!.writeTo(requestBuffer)
        return chain.proceed(
            request.newBuilder()
                .body(
                    object : HttpBody {
                        override val contentType = request.body!!.contentType

                        override val contentLength = requestBuffer.size

                        override fun writeTo(bufferedSink: BufferedSink) {
                            bufferedSink.writeAll(requestBuffer)
                        }
                    }
                )
                .build()
        )
    }
}

Use it like this:

    val apolloClient = ApolloClient.Builder()
        .serverUrl(...)
        // Make sure to configure batching first, before the interceptor
        .httpBatching(...)
        .addHttpInterceptor(ContentLengthHttpInterceptor())
        .build()

Note that this means the whole request body is first loaded into memory, which was avoided when using chunked.

[ArjanSM]

@BoD thank you for creating this issue.
I may be horribly wrong, but why can't we calculate the contentLength by iterating over the allbodies in the executePendingRequests function in the BatchingHttpInterceptor?
e.g

val body = object : HttpBody {
      override val contentType = "application/json"

      override val contentLength = allBodies.sumOf { it.contentLength }

      override fun writeTo(bufferedSink: BufferedSink) {
        val writer = BufferedSinkJsonWriter(bufferedSink)
        writer.writeArray {
          this as BufferedSinkJsonWriter
          allBodies.forEach { body ->
            val buffer = Buffer()
            body.writeTo(buffer)
            jsonValue(buffer.readUtf8())
          }
        }
      }
    }

[BoD]

@ArjanSM allBodies.sumOf { it.contentLength } is almost good, but the writeArray inside writeTo adds a few characters (the brackets and commas) - that should be accounted for in contentLength. The exact format of jsonValue is also not 100% defined, and so the total length may be a bit different than the sum of each body's length. Another case to consider is if contentLength returns -1 on one of the bodies.
So this approach may work but would be fragile, and there are a few pitfalls.

Another approach would be to read the bodies similarly to the workaround above, but with the drawback that it must load them in memory.

I think for the time being, given there's a workaround and that chunked seem to be accepted by (some or most?) servers, let's keep the issue open for now and see if it gather more interest.

(Sorry about putting the "Good First Issue" label, I didn't realize this is not that obvious in the end!)

[martinbonnin]

This issue has been open for a while now and didn't gather much interest. Given that there is a workaround, I'm closing it.