#multipart #future #requests #async-client #stream #server #field

mpart-async

Asynchronous (Futures-Base) Multipart Requests for Rust

11 releases (6 breaking)

0.7.0 Jan 17, 2024
0.6.1 Jul 31, 2022
0.6.0 Mar 22, 2022
0.5.0 Jan 22, 2021
0.1.0 May 31, 2018

#79 in Asynchronous

Download history 1019/week @ 2023-12-18 518/week @ 2023-12-25 1152/week @ 2024-01-01 2705/week @ 2024-01-08 1147/week @ 2024-01-15 1132/week @ 2024-01-22 1187/week @ 2024-01-29 1652/week @ 2024-02-05 1060/week @ 2024-02-12 1218/week @ 2024-02-19 2166/week @ 2024-02-26 1016/week @ 2024-03-04 1134/week @ 2024-03-11 1347/week @ 2024-03-18 1262/week @ 2024-03-25 1135/week @ 2024-04-01

4,947 downloads per month
Used in 4 crates (3 directly)

MIT/Apache

67KB
1K SLoC

Rust Multipart Async

This crate allows the creation of client/server multipart streams for use with std futures.

Quick Usage

With clients, you want to create a MultipartRequest & add in your fields & files.

Hyper Client Example

Here is an example of how to use the client with hyper (cargo run --example hyper):

use hyper::{header::CONTENT_TYPE, Body, Client, Request};
use hyper::{service::make_service_fn, service::service_fn, Response, Server};
use mpart_async::client::MultipartRequest;

type Error = Box<dyn std::error::Error + Send + Sync + 'static>;

#[tokio::main]
async fn main() -> Result<(), Error> {
    //Setup a mock server to accept connections.
    setup_server();

    let client = Client::new();

    let mut mpart = MultipartRequest::default();

    mpart.add_field("foo", "bar");
    mpart.add_file("test", "Cargo.toml");

    let request = Request::post("http://localhost:3000")
        .header(
            CONTENT_TYPE,
            format!("multipart/form-data; boundary={}", mpart.get_boundary()),
        )
        .body(Body::wrap_stream(mpart))?;

    client.request(request).await?;

    Ok(())
}

fn setup_server() {
    let addr = ([127, 0, 0, 1], 3000).into();
    let make_svc = make_service_fn(|_conn| async { Ok::<_, Error>(service_fn(mock)) });
    let server = Server::bind(&addr).serve(make_svc);

    tokio::spawn(server);
}

async fn mock(_: Request<Body>) -> Result<Response<Body>, Error> {
    Ok(Response::new(Body::from("")))
}

Warp Server Example

Here is an example of using it with the warp server (cargo run --example warp):

use warp::Filter;

use bytes::Buf;
use futures::stream::TryStreamExt;
use futures::Stream;
use mime::Mime;
use mpart_async::server::MultipartStream;
use std::convert::Infallible;

#[tokio::main]
async fn main() {
    // Match any request and return hello world!
    let routes = warp::any()
        .and(warp::header::<Mime>("content-type"))
        .and(warp::body::stream())
        .and_then(mpart);

    warp::serve(routes).run(([127, 0, 0, 1], 3030)).await;
}

async fn mpart(
    mime: Mime,
    body: impl Stream<Item = Result<impl Buf, warp::Error>> + Unpin,
) -> Result<impl warp::Reply, Infallible> {
    let boundary = mime.get_param("boundary").map(|v| v.to_string()).unwrap();

    let mut stream = MultipartStream::new(
        boundary,
        body.map_ok(|mut buf| buf.copy_to_bytes(buf.remaining())),
    );

    while let Ok(Some(mut field)) = stream.try_next().await {
        println!("Field received:{}", field.name().unwrap());
        if let Ok(filename) = field.filename() {
            println!("Field filename:{}", filename);
        }

        while let Ok(Some(bytes)) = field.try_next().await {
            println!("Bytes received:{}", bytes.len());
        }
    }

    Ok(format!("Thanks!\n"))
}

To interact with the server:

curl -F test=field -F file=@file.txt http://localhost:3030/

Dependencies

~2–4MB
~77K SLoC