florianuekermann / async-web-client Goto Github PK

have a look at what reqwest offers. At the very least we need to offer:

json
AsyncRead
Vec
String

Other ideas?

We don't want to require Clone on bodies or force the user to move them. &mut references should be sufficient (cloning non-body parts of the request is fine).

• implement non-cloneable bodies (like a fixed size AsyncRead wrapper).
• retain the request and body in the calling scope, which can be handy for context.

However, if possible passing body by reference or value (moving), should both be allowed, because users implementing their own futures on top may run into problems with lifetimes using references, while most other users would likely prefer a reference. Something like:
send(&self, body: AsMut<IntoRequestBody) or send(&self, body: BorrowMut<IntoRequestBody) maybe

We should probably add support custom transports, because why not. Something like send_via(&self, transport: impl AsyncRead + AsyncWrite + Unpin)

This would allow us to add tests which don't require network bits as well.

Maybe this should wait until the underlying protocol crate is in better shape and implements more of the state machine.

We want to support:

let request: http::Request<&str> = Request::post("http://postman-echo.com/post").body("jalsdfjlasdjflek")?;
reqeust.send().await?;

as well as

let request: http::Request<()> = Request::post("http://postman-echo.com/post").body(())?;
let response = request.send(Some("jalsdfjlasdjflek")).await?;

multiple ext traits and changes to IntoRequestBody) may be necessary. (IntoRequestBody has an impl for () atm, which may cause problems if both traits are used, assuming the user uses the prelude.rs

It should also be easy to send empty bodies using None or (), which may be a bit tricky because the T in Option<T> can't be inferred. Default type parameters may help... ...worst case we have to differentiation send() and send_with_body().

HTTP semantically doesn't really differentiate between 0 length body and no body, which opens up some more options like "" for no-body scenarios. But it would be good to find a solution that feels more idiomatic (like () or None).

We probably want to make send take a reference instead of moving the request as well...

A good first step may be to add test which cover all options we want to work. They don't need to actually do the async stuff, this is fine:

#[test]
fn test() {
    let request_without_body: http::Request<()> = Request::post("http://example.com").body(())?;
    let request_with_body: http::Request<()> = Request::post("http://example.com").body(())?;

    _ = request_without_body.send(Some("jalsdfjlasdjflek"));
    _ = request_without_body.send(None);
    _ = request_with_body.send();
}