A modern programming language that makes developers happier.

kotlinlang

Hello! Can anybody tell is there a way to receive a body of one response twice to avoid `DoubleReceiveException` in *ktor-client*? Or maybe there are ways to create some kind of feautre/plugin that receives the body at the `HttpReceivePipeline.After` phase, processes the body data and after continues piplene execution unchanged for the response? Is it possible?

<https://ktor.io/docs/double-receive.html|https://ktor.io/docs/double-receive.html>

Yep, it's for ktor-server. But what about ktor-client?

There is `ResponseObserver`  plugin that allows you to read copy of a body. It’s used for `Logging`  plugin.
Unfortunately, its installation is not that simple, so you may need a plugin that wraps it. Something like this should work
```    companion object MyObserver : HttpClientPlugin&lt;Unit, MyObserver&gt; {
        override val key = AttributeKey&lt;MyObserver&gt;("MyObserve")

        override fun prepare(block: Unit.() -&gt; Unit): MyObserver = this

        override fun install(plugin: MyObserver, scope: HttpClient) {
            val handler: ResponseHandler = { doSomethingWithResponse(it) }
            ResponseObserver.install(ResponseObserver(handler), scope)
        }
    }

    client.install(MyObserver)```


The `Logging` feature is the first thing that i looked at :slightly_smiling_face:`ResponseObserver` is useful plugin, but it works asynchronously. In my case, I need sequentially: to get a response, handle body of the content, and then using the result of the content processing decide to continue pipeline or, for example, throw an exception.

I made new feature but I'm not sure that the implementation is correct. It's work like this:
```scope.receivePipeline.intercept(HttpReceivePipeline.After) { response -&gt;
    val charset = response.contentType()?.charset() ?: Charsets.UTF_8
    // Get body from content
    val body = response.content.readRemaining().readText(
        charset = charset
    )

    // Processing body
    val result = handleBody(body)
    if (result) {
        // Just proceed pipeline
        val byteChannel = ByteReadChannel(
            body.toByteArray(charset)
        )
        proceedWith(context.wrapWithContent(byteChannel).response)
    } else {
        throw Exception()
    }
}```

I suggest you to use `responsePipeline`  instead, since it’s responsible for handling body of a response. Otherwise your code should work.