Remove unecessary changes to client.rs

Author: cwaldren-ld

contract-tests/src/bin/sse-test-api/main.rs

@@ -26,9 +26,6 @@ struct Config {
     /// test harness will send a value anyway in an attempt to avoid having reconnection tests
     /// run unnecessarily slowly.
     initial_delay_ms: Option<u64>,
-    /// An optional integer specifying the read timeout for the connection, in
-    /// milliseconds.
-    read_timeout_ms: Option<u64>,
     /// A JSON object containing additional HTTP header names and string values. The SSE
     /// client should be configured to add these headers to its HTTP requests; the test harness
     /// will then verify that it receives those headers. The test harness will only set this
@@ -72,7 +69,6 @@ async fn status() -> impl Responder {
             "comments".to_string(),
             "post".to_string(),
             "report".to_string(),
-            "read-timeout".to_string(),
             "headers".to_string(),
             "last-event-id".to_string(),
         ],

contract-tests/src/bin/sse-test-api/stream_entity.rs

@@ -10,7 +10,7 @@ use eventsource_client as es;
 
 use crate::{Config, EventType};
 
-type Connector = es::TimeoutConnector<es::HttpsConnector>;
+type Connector = es::HttpsConnector;
 
 pub(crate) struct Inner {
     callback_counter: Mutex<i32>,
@@ -101,10 +101,6 @@ impl Inner {
             reconnect_options = reconnect_options.delay(Duration::from_millis(delay_ms));
         }
 
-        if let Some(read_timeout_ms) = config.read_timeout_ms {
-            client_builder = client_builder.read_timeout(Duration::from_millis(read_timeout_ms));
-        }
-
         if let Some(headers) = &config.headers {
             for (name, value) in headers {
                 client_builder = match client_builder.header(name, value) {

eventsource-client/examples/tail.rs

@@ -36,9 +36,7 @@ async fn main() -> Result<(), es::Error> {
     Ok(())
 }
 
-fn tail_events(
-    client: es::Client<es::TimeoutConnector<es::HttpsConnector>>,
-) -> impl Stream<Item = Result<(), ()>> {
+fn tail_events(client: es::Client<es::HttpsConnector>) -> impl Stream<Item = Result<(), ()>> {
     client
         .stream()
         .map_ok(|event| {

eventsource-client/src/client.rs

@@ -11,33 +11,23 @@ use std::{
 use futures::{ready, Stream};
 use hyper::{
     body::{Bytes, HttpBody},
-    client::{
-        connect::{Connect, Connection},
-        ResponseFuture,
-    },
+    client::{connect::Connect, ResponseFuture},
     header::{HeaderMap, HeaderName, HeaderValue},
-    service::Service,
     Body, Request, StatusCode, Uri,
 };
 #[cfg(feature = "rustls")]
 use hyper_rustls::HttpsConnector as RustlsConnector;
 use log::{debug, info, trace, warn};
 use pin_project::pin_project;
-
-use tokio::{
-    io::{AsyncRead, AsyncWrite},
-    time::Sleep,
-};
+use tokio::time::Sleep;
 
 use super::config::ReconnectOptions;
 use super::decode::Decoded;
 use super::error::{Error, Result};
 
 pub use hyper::client::HttpConnector;
-
 #[cfg(feature = "rustls")]
 pub type HttpsConnector = RustlsConnector<HttpConnector>;
-pub use hyper_timeout::TimeoutConnector;
 
 /*
  * TODO remove debug output
@@ -48,7 +38,6 @@ pub struct ClientBuilder {
     url: Uri,
     headers: HeaderMap,
     reconnect_opts: ReconnectOptions,
-    read_timeout: Option<Duration>,
 }
 
 impl ClientBuilder {
@@ -64,12 +53,6 @@ impl ClientBuilder {
         Ok(self)
     }
 
-    /// Set a read timeout for the underlying connection. There is no read timeout by default.
-    pub fn read_timeout(mut self, read_timeout: Duration) -> ClientBuilder {
-        self.read_timeout = Some(read_timeout);
-        self
-    }
-
     /// Configure the client's reconnect behaviour according to the supplied
     /// [`ReconnectOptions`].
     ///
@@ -79,19 +62,12 @@ impl ClientBuilder {
         self
     }
 
-    pub fn build_with_conn<C>(self, conn: C) -> Client<TimeoutConnector<C>>
+    pub fn build_with_conn<C>(self, conn: C) -> Client<C>
     where
-        C: Service<Uri> + Send + 'static + std::clone::Clone,
-        C::Error: Into<Box<dyn std::error::Error + Send + Sync>>,
-        C::Future: Unpin + Send,
-        C::Response: AsyncRead + AsyncWrite + Connection + Unpin + Send,
+        C: Connect + Clone,
     {
-        let mut connector = TimeoutConnector::new(conn);
-        connector.set_read_timeout(self.read_timeout);
-        let client = hyper::Client::builder().build::<_, hyper::Body>(connector);
-
         Client {
-            http: client,
+            http: hyper::Client::builder().build(conn),
             request_props: RequestProps {
                 url: self.url,
                 headers: self.headers,
@@ -100,12 +76,12 @@ impl ClientBuilder {
         }
     }
 
-    pub fn build_http(self) -> Client<TimeoutConnector<HttpConnector>> {
+    pub fn build_http(self) -> Client<HttpConnector> {
         self.build_with_conn(HttpConnector::new())
     }
 
     #[cfg(feature = "rustls")]
-    pub fn build(self) -> Client<TimeoutConnector<HttpsConnector>> {
+    pub fn build(self) -> Client<HttpsConnector> {
         let conn = HttpsConnector::with_native_roots();
         self.build_with_conn(conn)
     }
@@ -150,7 +126,6 @@ impl Client<()> {
             url,
             headers: HeaderMap::new(),
             reconnect_opts: ReconnectOptions::default(),
-            read_timeout: None,
         })
     }
 }