A modern programming language that makes developers happier.

kotlinlang

I am using the http cio client -- how can I send an input stream to the client as the body?

Clearly I need to adapt the stream to an `OutgoingContent.WriteChannelContent` somehow, but its unclear to me how.

Actually, check that, I want to adapt a `java.io.Writer` (or  `OutputStream`) to the body.

```
suspend fun InputStream.toByteChannel(dispatcher: CoroutineDispatcher = ioCoroutineDispatcher): ByteReadChannel {
    val inputStream = this
    return writer(dispatcher) {
        while (true) {
            val temp = ByteArray(1024)
            val readSize = inputStream.read(temp)
            if (readSize &lt;= 0) break
            channel.writeFully(temp, 0, readSize)
        }
    }.channel
}
```

```
suspend fun OutputStream.toByteWriteChannel(dispatcher: CoroutineDispatcher = ioCoroutineDispatcher): ByteWriteChannel {
    val outputStream = this
    return reader(dispatcher) {
        while (true) {
            val temp = ByteArray(1024)
            val readSize = channel.readAvailable(temp)
            if (readSize &lt;= 0) break
            outputStream.write(temp, 0, readSize)
        }
    }.channel
}
```

Thanks <@U0BLPSJAK>, no built-ins for this? I see that coroutines io does have the analogue `ByteReadChannel.toInputStream()`.

Also, this assumes the existence of an `OutputStream`... I'd rather create an `OutputStream` connected to a `ByteWriteChannel`. So I think I just need to create a new `ByteWriteChannel` and call `toOutputStream` on it.

But where do I get the `ByteWriteChannel` from?

Can I just do `ByteChannel(true).toOutputStream()`?

<https://github.com/Kotlin/kotlinx-io/issues/4>

I’m not sure if there are already for inputstream

<https://github.com/Kotlin/kotlinx-io/blob/f7150df011d25a40453bcbf75e8bb9f83687b377/kotlinx-io-jvm/src/main/kotlin/kotlinx/io/streams/Streams.kt#L78>

Hmm, I'm still a little confused. I want to create a `OutgoingContent` that is a `ByteWriteChannel`, from which it looks like I can do `toOutputStream`. But it seems that class is internal, so I don't have a way to create it.

WriterContent({ … channel.write(…)… }, ContentType…)

`OutgoingContent` has several abstract inner classes, (if you look at the implementations of those classes)

So if I pass in an implementation of `WriteChannelContent` I'll get a `writeTo` callback in which I can write to the output stream?

<https://github.com/ktorio/ktor/blob/8e65dafbe7fdb36804fc0ccc357082140763fe79/ktor-server/ktor-server-core/src/io/ktor/content/WriterContent.kt#L8>

if you have a bytewritechannel, I guess you can copy from one to another

<@U0BLPSJAK> `WriterContent` worked as expected, BUT I note this class is in the server-core package, so it cannot easily be used as `OutgoingContent` in the ktor *client*.  Should this and other implementations of `OutgoingContent` be moved to somewhere common to client and server?

I would file an issue suggesting it: <https://github.com/ktorio/ktor/issues>

Done, thanks: <https://github.com/ktorio/ktor/issues/465>