HTTP request in Rust using hyper-rustls

main.rs

#[macro_use] extern crate derive_error;
extern crate futures;
extern crate hyper;
extern crate hyper_rustls;
extern crate tokio_core;

use futures::{Future, Sink, Stream, future};
use futures::sync::mpsc::{self, Sender};
use tokio_core::reactor::Core;
use hyper::client::{Client, HttpConnector};
use hyper::{Body, Chunk, Request};
use hyper_rustls::HttpsConnector;

use std::thread::{self, JoinHandle};

pub type OurClient = Client<HttpsConnector<HttpConnector>>;

#[derive(Debug, Error)]
pub enum OurError {
    Hyper(hyper::Error),
}

pub type OurFuture<T> = Box<Future<Item = T, Error = OurError>>;

pub type ClientRequest = Box<Fn(&OurClient) -> OurFuture<()> + Send + 'static>;

pub fn prepare() -> (Sender<ClientRequest>, JoinHandle<()>) {
    let (sender, receiver) = mpsc::channel(0);
    let handle = thread::spawn(move || {
        let mut core = Core::new().unwrap();
        let connector = HttpsConnector::new(4);
        let client = Client::builder().build(connector);
        let listen = receiver.for_each(|call: ClientRequest| {
            call(&client).map_err(|e| {
                println!("Error: {:?}", e);
            })
        });

        core.run(listen).unwrap();
    });
    (sender, handle)
}

fn main() {
    let (sender, handle) = prepare();

    let closure = Box::new(|client: &OurClient| -> OurFuture<()> {
        let req = Request::get("https://www.rust-lang.org")
                          .body(Body::empty()).unwrap();

        let future = client.request(req).map_err(OurError::from).and_then(|response| {
            let code = response.status();
            response.into_body().map_err(OurError::from).fold(vec![], |mut body: Vec<u8>, chunk: Chunk| {
                body.extend_from_slice(&chunk);
                future::ok::<_, OurError>(body)
            }).and_then(move |bytes: Vec<u8>| {
                println!("code: {}, response: {}", code,
                        String::from_utf8_lossy(&bytes));
                future::ok::<_, OurError>(())
            })
        });

        Box::new(future) as OurFuture<()>
    });

    let _ = sender.clone().send(closure).wait().map_err(|e| {
        // handle queueing error
    });

    handle.join().unwrap();
}