example working

Author: hjr3

Cargo.toml

@@ -21,5 +21,4 @@ tokio-reactor = "0.1"
 tokio-service = "0.1"
 
 [dev-dependencies]
-native-tls = "0.1"
-hyper-tls = "0.1"
+hyper-tls = "0.3"

examples/client.rs

@@ -1,56 +1,61 @@
-//extern crate futures;
-//extern crate tokio_core;
-//extern crate hyper;
-//extern crate hyper_tls;
-//extern crate hyper_timeout;
-//
-//use std::env;
-//use std::time::Duration;
-//
-//use futures::Future;
-//use futures::stream::Stream;
-//
-//use hyper::Client;
-//
-////use hyper::client::HttpConnector;
-//use hyper_tls::HttpsConnector;
-//
-//use hyper_timeout::TimeoutConnector;
-//
-//fn main() {
-//
-//    let url = match env::args().nth(1) {
-//        Some(url) => url,
-//        None => {
-//            println!("Usage: client <url>");
-//            return;
-//        }
-//    };
-//
-//    let url = url.parse::<hyper::Uri>().unwrap();
-//
-//    let mut core = tokio_core::reactor::Core::new().unwrap();
-//    let handle = core.handle();
-//
-//    // This example uses `HttpsConnector`, but you can also use the default hyper `HttpConnector`
-//    //let connector = HttpConnector::new(4, &handle);
-//    let connector = HttpsConnector::new(4, &handle).unwrap();
-//    let mut tm = TimeoutConnector::new(connector, &handle);
-//    tm.set_connect_timeout(Some(Duration::from_secs(5)));
-//    tm.set_read_timeout(Some(Duration::from_secs(5)));
-//    tm.set_write_timeout(Some(Duration::from_secs(5)));
-//    let client = Client::configure().connector(tm).build(&handle);
-//
-//    let get = client.get(url).and_then(|res| {
-//        println!("Response: {}", res.status());
-//        println!("Headers: \n{}", res.headers());
-//
-//        res.body().concat2()
-//    });
-//
-//    let got = core.run(get).unwrap();
-//    let output = String::from_utf8_lossy(&got);
-//    println!("{}", output);
-//}
-
-fn main() {}
+extern crate futures;
+extern crate hyper;
+extern crate hyper_tls;
+extern crate hyper_timeout;
+
+use std::env;
+use std::io::{self, Write};
+use std::time::Duration;
+
+use futures::Future;
+use futures::stream::Stream;
+
+use hyper::{rt, Client};
+
+//use hyper::client::HttpConnector;
+use hyper_tls::HttpsConnector;
+
+use hyper_timeout::TimeoutConnector;
+
+fn main() {
+
+    let url = match env::args().nth(1) {
+        Some(url) => url,
+        None => {
+            println!("Usage: client <url>");
+            println!("Example: client https://example.com");
+            return;
+        }
+    };
+
+    let url = url.parse::<hyper::Uri>().unwrap();
+
+    rt::run(rt::lazy(|| {
+        // This example uses `HttpsConnector`, but you can also use hyper `HttpConnector`
+        //let connector = HttpConnector::new(1);
+        let https = HttpsConnector::new(1).unwrap();
+        let mut connector = TimeoutConnector::new(https);
+        connector.set_connect_timeout(Some(Duration::from_secs(5)));
+        connector.set_read_timeout(Some(Duration::from_secs(5)));
+        connector.set_write_timeout(Some(Duration::from_secs(5)));
+        let client = Client::builder().build::<_, hyper::Body>(connector);
+
+        client.get(url).and_then(|res| {
+            println!("Response: {}", res.status());
+
+            res
+                .into_body()
+                // Body is a stream, so as each chunk arrives...
+                .for_each(|chunk| {
+                    io::stdout()
+                        .write_all(&chunk)
+                        .map_err(|e| {
+                            panic!("example expects stdout is open, error={}", e)
+                        })
+                })
+        })
+        .map_err(|err| {
+            println!("Error: {}", err);
+        })
+    }));
+}

src/lib.rs

@@ -43,7 +43,7 @@ impl<T: Connect> TimeoutConnector<T> {
 impl<T: Connect> Connect for TimeoutConnector<T>
 where
     T: Connect<Error = io::Error> + 'static,
-    T::Future: Future<Error = io::Error>,
+    T::Future: 'static,
 {
     type Transport = TimeoutStream<T::Transport>;
     type Error = T::Error;