1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

#![deny(missing_docs)]
//! # Rust Multipart Async
//!
//! This crate allows the creation of client/server `multipart/form-data` streams for use with std futures & async
//! ## Quick Usage
//!
//! With clients, you want to create a [`MultipartRequest`](client/struct.MultipartRequest.html) & add in your fields & files.
//!
//! With server, you want to use a [`MultipartStream`](server/struct.MultipartStream.html) to retrieve a stream of streams.
//!
//! You can also use the lower level [`MultipartParser`](server/struct.MultipartParser.html) to retrieve a stream emitting either Headers or Byte Chunks
//!
//! ### Hyper Client Example
//!
//! Here is an example of how to use the client with hyper:
//!
//! ```no_run
//! 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:
//!
//! ```no_run
//! use warp::Filter;
//!
//! use bytes::Buf;
//! use futures_util::TryStreamExt;
//! use futures_core::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"))
//! }
//! ```

/// The Client Module used for sending requests to servers
///
pub mod client;
/// Server structs for use when parsing requests from clients
pub mod server;

/// The FileStream is a tokio way of streaming out a file from a given path.
///
/// This allows you to do `FileStream::new("/path/to/file")` to create a stream of Bytes of the file
#[cfg(feature = "filestream")]
pub mod filestream;