Example of how to return a file dynamically

[ufoscout]

I am having a hard time trying to return binary data from one of my routes. My use case is that when a /download route is called, I need to return a file that depends on the caller profile and context.
I cannot use tower_http::services::ServeDir because in my case the file is selected dynamically. In addition, it could be served from the filesystem or from a database.

Would it be possible to include an example that shows how to:

• return a file from the filesystem or generic binary data
• set the response ContentDisposition/DispositionParameters/DispositionType

[davidpdrsn]

You can do this:

use axum::{
    body::StreamBody,
    http::{header, StatusCode},
    response::{Headers, IntoResponse},
    routing::get,
    Router,
};
use std::net::SocketAddr;
use tokio_util::io::ReaderStream;

#[tokio::main]
async fn main() {
    let app = Router::new().route("/", get(handler));

    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

async fn handler() -> impl IntoResponse {
    // `File` implements `AsyncRead`
    let file = match tokio::fs::File::open("Cargo.toml").await {
        Ok(file) => file,
        Err(err) => return Err((StatusCode::NOT_FOUND, format!("File not found: {}", err))),
    };
    // convert the `AsyncRead` into a `Stream`
    let stream = ReaderStream::new(file);
    // convert the `Stream` into an `axum::body::HttpBody`
    let body = StreamBody::new(stream);

    let headers = Headers([
        (header::CONTENT_TYPE, "text/toml; charset=utf-8"),
        (
            header::CONTENT_DISPOSITION,
            "attachment; filename=\"Cargo.toml\"",
        ),
    ]);

    Ok((headers, body))
}

[AThilenius]

Ah, got it. Hopefully 😁

async fn get_file(
    State(state): State<AppState>,
    Path(md5): Path<String>,
    query: Query<FileQuery>,
 ) -> Result<Response, Error> {
    // ...
    Ok((headers, body).into_response())
}

[danielecr]

axum::body::StreamBody and axum::response::Headers does not resolve in axum 0.7

[davidpdrsn]

StreamBody is now Boody::from_data_stream and Headers has been removed since its not needed. See #608 (reply in thread)

[simonsan]

@davidpdrsn Just asking, because I'm confused: You meant Body::from_stream(), right?

[davidpdrsn]

Yes sorry!

[MidKnightXI]

I'm sorry to comment on a really old discussion but I'm new to axum and I'm trying to send an image based on the path given by the request.

I based my code on the answer because I cannot find how to do what I'm trying to do with axum but the Header part is apparently missing from axum::response, do you know where can I find it?

a similar name exists in the module: `header`rustc[E0432](https://doc.rust-lang.org/error-index.html#E0432)
images.rs(5, 16): original diagnostic
unresolved import `axum::response::Headers`
no `Headers` in `response`

Here is my code to have more context about what I'm trying to do:

#[derive(Deserialize)]
pub struct QueryParams {
    path: String,
}

pub async fn get_image(
    Query(QueryParams { path }): Query<QueryParams>
) -> impl IntoResponse {
    let filename = match PathBuf::from(path).file_name() {
        Some(name) => name,
        None => return Err((StatusCode::BAD_REQUEST, "File name couldn't be determined".to_string()))
    };
    let file = match tokio::fs::File::open(path).await {
        Ok(file) => file,
        Err(err) => return Err((StatusCode::NOT_FOUND, format!("File not found: {}", err)))
    };
    let content_type = match mime_guess::from_path(&path).first_raw() {
        Some(mime) => mime,
        None => return Err((StatusCode::BAD_REQUEST, "MIME Type couldn't be determined".to_string()))
    };

    let stream = ReaderStream::new(file);
    let body = StreamBody::new(stream);

    let headers = Headers([
        (header::CONTENT_TYPE, content_type),
        (
            header::CONTENT_DISPOSITION,
            &format!("attachment; filename=\"{:?}\"", filename),
        ),
    ]);

    Ok((headers, body))
}

Also yeah atm if the code was working it could return any file possible, I'll add the possibility to check if the file is an image after that

[AThilenius]

You need to enable the headers feature. Axum has lots of things disabled by default, so it's worth taking a quick look through the available features list.

[MidKnightXI]

Even with the feature enabled, Header cannot be find.

# Cargo.toml

[dependencies]
axum = { version = "0.6.18", features = ["headers"] }
diesel = { version = "2.1.0", features = ["sqlite"]}
libsqlite3-sys = { version = "0.25.2", features = ["bundled"] }
dirs = "5.0.1"
serde = { version = "1.0.163", features = ["derive"] }
serde_json = "1.0.96"
tokio = { version = "1.28.1", features = ["macros", "rt-multi-thread", "fs"] }
image = "0.24.6"
http = "0.2.9"
axum-macros = "0.3.7"
tower-http = { version = "0.4.0", features = ["fs"] }
mime_guess = "2.0.4"
tokio-util = "0.7.8"

// imports in the handler file

use std::{fs, path::PathBuf};

use axum::{
    Json,
    http::{header, StatusCode},
    response::{Headers, IntoResponse},
    extract::Query,
    body::StreamBody
};
use serde::Deserialize;
use serde_json::json;
use tokio_util::io::ReaderStream;

error[E0432]: unresolved import `axum::response::Headers`
 --> src/images.rs:6:16
  |
6 |     response::{Headers, IntoResponse},
  |                ^^^^^^^
  |                |
  |                no `Headers` in `response`
  |                help: a similar name exists in the module: `header`

For more information about this error, try `rustc --explain E0432`.
error: could not compile `rs-api` due to previous error

[davidpdrsn]

The Headers type has been removed. You can just use

let headers = [
    (header::CONTENT_TYPE, content_type),
    (
        header::CONTENT_DISPOSITION,
        &format!("attachment; filename=\"{:?}\"", filename),
    ),
];

without the wrapper type.

[hanusek]

Hello. I have a similar problem.
The downloaded file is empty.
I can't pass let f : Vec<u8> = model.file.unwrap(); to StreamBody.
How to fix it?
My functions:

pub async fn download(state: State<AppState>, Path(path): Path<String>) -> impl IntoResponse {
    info!("id: {:?}", path);
    let model = QueryCore::find_post_by_id(&state.conn, 17)
        .await
        .expect("Cannot find posts in page")
        .unwrap();

    let f : Vec<u8> = model.file.unwrap();
    info!("f: {:?}", f);

    let mut file = OpenOptions::new()
        .read(true)
        .write(true)
        .create(true)
        .open("YourFileName.toml")
        .await
        .unwrap();

    file.write(&f).await.unwrap();
    file.flush().await.unwrap();
    file.sync_all().await.unwrap();
    file.shutdown().await.unwrap();

    let mut contents = vec![];
    file.read_to_end(&mut contents).await.unwrap();
    info!("contents: {:?}", contents);

    let stream = ReaderStream::new(file);

    let body = StreamBody::new(stream);
    let headers = [
        (header::CONTENT_TYPE, "text/toml; charset=utf-8"),
        (
            header::CONTENT_DISPOSITION,
            "attachment; filename=\"YourFileName.toml\"",
        ),
    ];
    (headers, body).into_response()
}

pub async fn download2(state: State<AppState>, Path(path): Path<String>) -> impl IntoResponse {
    info!("id: {:?}", path);
    let model = QueryCore::find_post_by_id(&state.conn, 17)
        .await
        .expect("Cannot find posts in page")
        .unwrap();

    let f : Vec<u8> = model.file.unwrap();
    info!("f: {:?}", f);

    let mut file = OpenOptions::new()
        .read(true)
        .write(true)
        .create(true)
        .open("YourFileName.toml")
        .await
        .unwrap();

    file.write(&f).await.unwrap();
    file.flush().await.unwrap();
    file.sync_all().await.unwrap();
    file.shutdown().await.unwrap();

    let mut contents = vec![];
    file.read_to_end(&mut contents).await.unwrap();
    info!("contents: {:?}", contents);
        let body = AsyncReadBody::new(file);

    let headers = [
        (header::CONTENT_TYPE, "text/toml; charset=utf-8"),
        (
            header::CONTENT_DISPOSITION,
            "attachment; filename=\"YourFileName.toml\"",
        ),
    ];
    (headers, body).into_response()
}

log:

2023-11-17T21:15:40.905161Z  INFO axum_example_api: id: "779"    
2023-11-17T21:15:40.905997Z  INFO axum_example_api: f: [84, 69, 83, 84, 49, 50, 49, 50, 51, 10]    
2023-11-17T21:15:40.924035Z  INFO axum_example_api: contents: []    

[davidpdrsn]

If you have the data in memory already then you don’t need a stream. You can just make the body with Body::from(vec_u8).

[hanusek]

@davidpdrsn thanks for your reply.

   let f : Vec<u8> = model.file.unwrap();
   let body = Body::from(f);
    let headers = [
        (header::CONTENT_TYPE, "text/toml; charset=utf-8"),
        (
            header::CONTENT_DISPOSITION,
            "attachment; filename=\"YourFileName.toml\"",
        ),
    ];
    (headers, body).into_response()

error:

error[E0599]: the method `into_response` exists for tuple `([(HeaderName, &str); 2], Body)`, but its trait bounds were not satisfied
   --> api/src/lib.rs:217:21
    |
217 |     (headers, body).into_response()
    |                     ^^^^^^^^^^^^^ method cannot be called on `([(HeaderName, &str); 2], Body)` due to unsatisfied trait bounds
    |
   ::: /home/mhanusek/.cargo/registry/src/index.crates.io-6f17d22bba15001f/hyper-0.14.27/src/body/body.rs:36:1
    |
36  | pub struct Body {
    | --------------- doesn't satisfy `Body: IntoResponse`
    |
    = note: the following trait bounds were not satisfied:
            `Body: IntoResponse`
            which is required by `([(HeaderName, &str); 2], Body): IntoResponse`

[davidpdrsn]

Ah sorry my bad. Body doesn't implement IntoResponse but Vec<u8> does. So

   let f : Vec<u8> = model.file.unwrap();
    let headers = [
        (header::CONTENT_TYPE, "text/toml; charset=utf-8"),
        (
            header::CONTENT_DISPOSITION,
            "attachment; filename=\"YourFileName.toml\"",
        ),
    ];
    (headers, f).into_response()

should work.

[hanusek]

Yes! It's working! ;)

[rogusdev]

Thank you! This was very helpful. Relatedly, this all seems quite critical knowledge for some important use cases. Does this have an example or documentation somewhere? And is the setup still accurate, or have there been improvements in the last 2 years (aside from Headers going away)?

[davidpdrsn]

We don’t have an example for it in the repo but I agree we probably should. Would you be up for submitting a PR?

[MidKnightXI]

I think making an example with a stream and mime_guess might be explanatory enough?

If you want to submit a PR you can take example on the solution of the thread I created some time ago.

I can also submit one if needed 👍

[davidpdrsn]

Sure!

I think the example should mention that https://docs.rs/tower-http/latest/tower_http/services/struct.ServeFile.html exists, which has more features such as support for range requests.

[rogusdev]

I am happy to add an example into https://github.com/tokio-rs/axum/tree/main/examples but I feel like this is something I might not have discovered given the number of examples already there. Some reference to it somewhere in the official docs would also be nice. Is there a place you think would be appropriate in https://docs.rs/axum/latest/axum/index.html?

Also, one thing I found important to make this useful for such large files is content length, which I will include in the example:

    let content_length = std::fs::metadata(&path).as_internal_err()?.len();
    let headers = [
        (header::CONTENT_LENGTH, content_length.to_string()),
...
    ];

[davidpdrsn]

Is there a place you think would be appropriate in https://docs.rs/axum/latest/axum/index.html?

I think just having an example for it in the repo is fine. I doubt it's gonna be easier to find on docs.rs and there isn't really an obvious place to mention it.

[Mivik]

For future googlers, I would suggest using ServeFile::try_call.

async fn download_file(headers: HeaderMap) -> Response {
    // Do some work...
    let path = todo!();

    let mut req = Request::new(Body::empty());
    *req.headers_mut() = headers;
    ServeFile::new(path).try_call(req).await.unwrap()
}

This is much simpler, and supports features like range requests as well.

[zopieux]

Thanks, this is definitely best. This seems to be the “low level” way of calling Tower's oneshot feature, which is probably a bit better in spirit, though entirely equivalent.

Also, I'm not a fan of having to create the request manually when it's already available by extraction, so what I'd suggest doing instead is:

use tower::ServiceExt;  // For oneshot().

async fn my_route(
  /* any amount of extractors here */,
  request: axum::extractor::Request  // PITFALL: this needs to be the last extractor, otherwise compiler complains.
) -> Result<impl IntoResponse, YouError> {
  ServeFile::new(path)/* or any other Tower/axum service */.oneshot(request).await
}

If you need to customize the response post-oneshot, you can always wrap it further, for instance:

{
  let response = /* */.oneshot(request).await?;
  Ok(( [(header::CONTENT_TYPE, "text/plain")], response ))
}

[Magicloud]

This thread should be updated since in 0.7, StreamBody is gone (not quite mentioned in changelog).

[davidpdrsn]

You can use Body::from_stream instead.

[Magicloud]

Thanks. I read about that function, but not sure if the body I get from it still works as a stream. Will try it.

[AThilenius]

It's a breaking change for axum-connect, here. Replacing StreamBody::new(res) with Body::from_stream(res) gives me:

future cannot be sent between threads safely
required for the cast from `Pin<Box<[async block@axum-connect/src/handler/handler_stream.rs:59:18: 142:10]>>` to `Pin<Box<(dyn futures::Future<Output = Response<Body>> + std::marker::Send + 'static)>>`rustc[Click for full compiler diagnostic](rust-analyzer-diagnostics-view:/diagnostic%20message%20%5B0%5D?0#file%3A%2F%2F%2Fhome%2Falec%2Fdev%2Faxum-connect%2Faxum-connect%2Fsrc%2Fhandler%2Fhandler_stream.rs)
codec.rs(132, 6): opaque type is declared here
handler_stream.rs(58, 8): this item depends on auto traits of the hidden type, but may also be registering the hidden type. This is not supported right now. You can try moving the opaque type and the item that actually registers a hidden type into a new submodule
handler_stream.rs(79, 91): future is not `Send` as this value is used across an await

I don't have time to debug it, running under the assumption that the new Body isn't Send/Sync? I'll pin to 0.6 for now.

[davidpdrsn]

Body is Send https://docs.rs/axum/0.7.2/axum/body/struct.Body.html#impl-Send-for-Body but !Sync (because streams don’t need to be Sync because you need a mutable reference to do anything with them)

[AThilenius]

That makes perfect sense. I had a bit of time to work on axum-connect, that error was a red herring; it had nothing to do with the Body::from_stream(res) change. The TBody template type wasn't needed any more for axum:0.7 fixed/updated here.

Have I mentioned how much I adore Axum 🥰

[hackers267]

It worked for me. But how can I do something when the response or finish is over?

[Ali-Javanmardi]

Hi,

I'm trying to download (stream) files stored by Apache Object Store .
I can convert object_store result to bytes but in case of large files there will be a memory problem.

So I decided to use stream instead.

In the document it says:

// Alternatively stream the bytes from object storage
let stream = object_store.get(&path).await.unwrap().into_stream();

in this case the type of stream is:
Pin<Box<dyn Stream<Item = Result<Bytes, Error>> + Send>>

So then when I try to create body :

let headers = ...
let body = Body::from_stream(stream);

return(Ok(headers, body))

I receive error:

     rustc:  cannot return value referencing temporary value
     returns a value referencing data owned by the current function

I hope it explains my problem and somebody can help me convert this stream from object_store to Response body.

[jplatte]

It's not really clear where the error originates. The full code for your handler and full error should help figuring this out.

[Ali-Javanmardi]

@jplatte Thanks for your comment,

As you said I checked a full error message from build process and found that error come from headers and not from stream.
Up to now I was relying on rust-analayzer error showed in the editor.

I will check more on my headers and will update here.

[Ali-Javanmardi]

Now I found my problem:

I have copied headers from this post above:

let headers = [
    (header::CONTENT_TYPE, content_type),
    (
        header::CONTENT_DISPOSITION,
        &format!("attachment; filename=\"{:?}\"", filename),
    ),
];

and now I see here second items of tuples are &str, so rustc compiler claims about their ownership,
I converted them to string and error cleared.

Thanks for your help,