Allow hyper::Body to be created from Read or AsyncRead

[cetra3]

I'd like to be able to construct a response from a static File or a Read interface. Not sure if this is already possible.

I.e,

    let f = File::open("example.txt").unwrap();
    let body = hyper::Body::from(f);

[srijs]

Hi @cetra3! When building a response, you are not forced to use hyper::Body. In fact, you can use any other type that implements futures::Stream.

To get from a std::io::File to a Stream you can use the futures-fs crate, for instance.

As an example:

// initialise fs pool somewhere in your server
let pool = futures_fs::FsPool::default();

// later, in a request handler
let file_read_stream = pool.read("example.txt");
let response = hyper::Response::new().with_body(file_read_stream);

[srijs]

@seanmonstar should we add this to the guide?

[seanmonstar]

Sorry, didn't write here as the user also asked on Reddit, and got several answers.

The guide does try to touch on the stream being able to be changed, but it might not be that obvious. Probably the guide should be more properly designed, instead of the sort of mishmash I've put together so far...

[xinghun92]

I use a Stream to construct a Request like this.

let mut request = ::hyper::Request::new(::hyper::Method::Post, ::hyper::Uri::from_str("http://www.google.com").unwrap());
let pool = FsPool::default();
let file_read_stream = pool.read("test.txt");
request.set_body(file_read_stream);

And I can not compile it, the error is

the trait `std::convert::From<futures_fs::FsReadStream>` is not implemented for `hyper::Body`

How to fix it? thank you!

[srijs]

@xinghun92 Try explicitly creating a Request<FsReadStream>:

let mut request: ::hyper::Request<FsReadStream> = ::hyper::Request::new(::hyper::Method::Post, ::hyper::Uri::from_str("http://www.google.com").unwrap());
let pool = FsPool::default();
let file_read_stream = pool.read("test.txt");
request.set_body(file_read_stream);

[xinghun92]

It fails when send this request using client.

let mut core = tokio_core::reactor::Core::new().unwrap();
let handle = core.handle();
let client = Client::new(&handle);
let work = client.request(request).and_then(|res| {
    println!("Response: {}", res.status());
    println!("Headers: \n{}", res.headers());

    res.body().for_each(|chunk| {
        io::stdout().write_all(&chunk).map_err(From::from)
    })
}).map(|_| {
    println!("\n\nDone.");
});

The error is

let work = client.request(request).and_then(|res| {
    |                               ^^^^^^^ expected struct `hyper::Body`, found struct `futures_fs::FsReadStream`

[srijs]

Hmm, seems like this is starting to become more tricky. Your current problem would be solved by using Client::configure().body::<FsReadStream>().build(), but then the next problem will be that FsReadStream has error type std::io::Error, where Config::build() expects the body to have error type hyper::Error

@seanmonstar Can you think of anything that might make this easier? For instance, could we change Config::build and Client::request so that they can automatically cast errors?

I'm thinking something like

impl<B> Config<UseDefaultConnector, B>
where B: Stream,
      B::Item: AsRef<[u8]>,
      B::Error: Into<Error>,
{
    ...
}

impl<C, B> Client<C, B> 
where
    C: Connect,
    B: Stream + 'static,
    B::Item: AsRef<[u8]>,
    B::Error: Into<Error>,
{
    ...
}

[seanmonstar]

Having Into there would probably be nice. This is actually a case of why #1129 exists. I would wish that users would not have to give a hyper::Error back to hyper to signify that the stream is busted...

[cetra3]

@srijs I'm using the shio-rs framework that requires a hyper::Body to be sent in the response so the proposed methods here don't work.

I've implemented a workaround using the hyper::Body::pair() function, but it's very complex to do so, and has its own issues with futures.

So it is possible to still use hyper::Body with a file stream which is good, but the ergonomics around it is pretty bad.

[mehcode]

@cetra3 Could you open an issue on Shio? We should generalize and support this.