Write stream chunks directly to the output stream

[mokhaled2992]

Summary

I'm aware that there are 3 types of response bodies:

• empty
• fixed
• stream

I'm interested in the stream where I have a vector of inputs and I want to convert it on the fly to a stream of bytes send it back as a chunked response (transfer-encoding: chunked). However, for the stream response type you have to yield chunks. I implemented the following working solution which provides an async stream that yields chunks of bytes. Is there any way to write directly to the output stream without going over this hop of creating and yielding intermediate buffers?

pub struct MyType;

pub struct MyStream {
  input: IntoIter<MyType>
}

impl MyStream {
    fn new(input: Vec<MyType>) -> Self {
       Self { input: input.into_iter() }
    }
}

impl Iterator for MyStream {
    type Item = Vec<u8>;
    fn next(&mut self) -> Option<Self::Item> {
       let Some(item) = self.input.next() else {return None;};
       let mut bytes = Vec::new();
       write_my_type(&item, &mut bytes);
       Some(bytes)
    }
}

impl Stream for MyStream {
    type Item = Bytes;
    fn poll_next(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
        Poll::Ready(self.get_mut().next().map(|x| x.map(|x| x.into())))
    }
}

axum version

0.7.5

[mladedav]

First, you can use futures::stream::iter to accomplish what you created manually.

But really, you can already take the body of the request as a stream and simply map it to the output you want and return that.

[mokhaled2992]

Can you elaborate more? Do you mean something like the following?

request.body().into_data_stream().map()

I might have misued the word input in my question, the body of the request is not a Vec<MyType>, this is rather an internal format for computation results, and it needs to be converted to some other output format.

[jplatte]

Instead of writing to a Vec<u8> and then converting that to Bytes, would it be possible for you to create a BytesMut, write to that and then freeze it? Any copies would be essentially free then since cloning Bytes just means incrementing a refcount.

[mokhaled2992]

Thanks for the suggestion, this looks more efficient than what I'm doing because it would save the conversion between Vec<u8> to Bytes but I would still be allocating N chunks of Bytes. Wouldn't those be eventually still deep copied onto the output stream? If so, is there no way to somehow write the output directly on the output stream?

[jplatte]

That's a level too low for me. Maybe try asking in hyper's Discussions section? axum doesn't implement any of that itself, axum::serve is just a very thin wrapper over hyper.