Accessing Response Body for further handling

[jakob-ledermann]

As far as I see there is no way for a consumer to access the body of a HttpResponse for further handling.

I want to query an REST API Endpoint which is responding with JSON.

Library works great, after I found out how to use a TlsStream instead of a simple TcpStream which was totally unrelated to this library.

Would be great if you could add a way to read the body of a response.

[matt2xu]

Hey @jakob-ledermann, I'm so sorry I just saw your issue only now; I need to change my notification settings. You're right, the HttpResponse is missing an accessor for the body. Would it be enough to have a body() -> &[u8] function? You can then use the JSON framework of your choice to parse the body. Or if you have other suggestions/requests I'm happy to hear them!

Where can I find the TlsStream you mention? Are you using it to make HTTPS requests?

[jakob-ledermann]

Hey @matt2xu, no problem since I added a simliar function: get_bod(&self) -> Vec by myself in a fork. It is actually pushed to github now. If you want i can submit a pull request.

The TlsStream is used to make HTTPS requests as you already guessed below are the parts of my code I use to make the request. It might be a good idea to include a sample to use for HTTPS also the difference is the tokio initialisation and not this library.
`
extern crate async_http_client;
extern crate tokio_tls;
extern crate native_tls;

use self::async_http_client::prelude::*;
use self::async_http_client::{HttpCodec, HttpRequest, HttpResponse};
use self::native_tls::TlsConnector;
use self::tokio_tls::TlsConnectorExt;

let mut req: HttpRequest = HttpRequest::get(url).unwrap();
let mut core: Core = Core::new().unwrap();
let addr = req.addr().unwrap();

let handle = core.handle();
let cx = TlsConnector::builder().unwrap().build().unwrap();

let connection = TcpStream::connect(&addr, &handle);

let tls_handshake = connection.and_then(|socket| {
    cx.connect_async(hostname, socket).map_err(|e| {
        io::Error::new(io::ErrorKind::Other, e)
    })
});

let (res, framed) = core.run(tls_handshake.and_then(|connection| {
    let framed = connection.framed(HttpCodec::new());
    let result = req.send(framed);
    return result;
})).unwrap();

return res.unwrap();

`

[matt2xu]

I would gladly accept a pull request for that! Nitpicking: I would rename the function body rather than get_body to follow the conventions of the Rust standard library (like len or bytes for instance); and I would change the return type to a slice of bytes to avoid a copy.

Also +1 to add an example with HTTPS, if you have some code ready feel free to do a PR, or otherwise I'll start from the code you wrote above.

[matt2xu]

Hi @jakob-ledermann for your information there is now an HTTPS example contributed by @xenzh, does it suit your needs?