Struct axum_extra::body::AsyncReadBody

pub struct AsyncReadBody<R> { /* private fields */ }

Available on crate feature async-read-body only.

An HttpBody created from an AsyncRead.

Example

AsyncReadBody can be used to stream the contents of a file:

use axum::{
    Router,
    routing::get,
    http::{StatusCode, header::CONTENT_TYPE},
    response::{Response, IntoResponse},
};
use axum_extra::body::AsyncReadBody;
use tokio::fs::File;

async fn cargo_toml() -> Result<Response, (StatusCode, String)> {
    let file = File::open("Cargo.toml")
        .await
        .map_err(|err| {
            (StatusCode::NOT_FOUND, format!("File not found: {}", err))
        })?;

    let headers = [(CONTENT_TYPE, "text/x-toml")];
    let body = AsyncReadBody::new(file);
    Ok((headers, body).into_response())
}

let app = Router::new().route("/Cargo.toml", get(cargo_toml));

Implementations

impl<R> AsyncReadBody<R>

pub fn new(read: R) -> Self where
    R: AsyncRead + Send + 'static, 

Create a new AsyncReadBody.

Trait Implementations

impl<R> Body for AsyncReadBody<R> where
    R: AsyncRead + Send + 'static, 

type Data = Bytes

Values yielded by the Body.

type Error = Error

The error type this Body might generate.

fn poll_data(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Option<Result<Self::Data, Self::Error>>>

Attempt to pull out the next data buffer of this stream.

fn poll_trailers(
    self: Pin<&mut Self>,
    _cx: &mut Context<'_>
) -> Poll<Result<Option<HeaderMap>, Self::Error>>

Poll for an optional single HeaderMap of trailers.

fn is_end_stream(&self) -> bool

Returns true when the end of stream has been reached.

fn size_hint(&self) -> SizeHint

Returns the bounds on the remaining length of the stream.

fn data(&mut self) -> Data<'_, Self> where
    Self: Unpin, 

Returns future that resolves to next data chunk, if any.

fn trailers(&mut self) -> Trailers<'_, Self> where
    Self: Unpin, 

Returns future that resolves to trailers, if any.

fn map_data<F, B>(self, f: F) -> MapData<Self, F> where
    F: FnMut(Self::Data) -> B,
    B: Buf, 

Maps this body’s data value to a different value.

fn map_err<F, E>(self, f: F) -> MapErr<Self, F> where
    F: FnMut(Self::Error) -> E, 

Maps this body’s error value to a different value.

fn boxed(self) -> BoxBody<Self::Data, Self::Error> where
    Self: 'static + Send + Sync, 

Turn this body into a boxed trait object.

fn boxed_unsync(self) -> UnsyncBoxBody<Self::Data, Self::Error> where
    Self: 'static + Send, 

Turn this body into a boxed trait object that is !Sync.

impl<R: Debug> Debug for AsyncReadBody<R>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<R> IntoResponse for AsyncReadBody<R> where
    R: AsyncRead + Send + 'static, 

fn into_response(self) -> Response

Create a response.

impl<'__pin, R> Unpin for AsyncReadBody<R> where
    __Origin<'__pin, R>: Unpin,