Add ability to set the request timeout for the HTTP client

Author: stevepryde

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "thirtyfour"
-version = "0.22.0"
+version = "0.21.0"
 authors = ["Steve Pryde <steve@stevepryde.com>"]
 edition = "2018"
 license = "MIT OR Apache-2.0"
@@ -20,7 +20,7 @@ categories = ["api-bindings", "development-tools::testing", "web-programming::ht
 [features]
 default = ["tokio-runtime", "reqwest-default-tls"]
 tokio-runtime = ["tokio", "reqwest"]
-async-std-runtime = ["async-std", "surf"]
+async-std-runtime = ["async-std", "surf", "isahc", "http-client"]
 
 reqwest-default-tls = ["reqwest/default-tls"]
 reqwest-native-tls = ["reqwest/native-tls"]
@@ -32,7 +32,9 @@ async-trait = "0.1"
 futures = "0.3"
 tokio = { version = "0.2", features = ["fs", "macros", "rt-threaded", "io-util"], optional = true }
 reqwest = { version = "0.10", features = ["json"], optional = true }
-async-std = { version = "1.6", features = ["attributes"], optional = true }
+http-client = { version = "6.2", optional = true }
+isahc = { version = "0.9", optional = true }
+async-std = { version = "1.8", features = ["attributes"], optional = true }
 surf = { version = "2.0.0-alpha.5", features = ["curl-client"], optional = true }
 serde_json = { version = "1.0", features = ["preserve_order"] }
 serde = { version = "1.0", features = ["derive"] }

src/http/connection_async.rs

@@ -4,6 +4,7 @@ use async_trait::async_trait;
 
 use crate::error::WebDriverResult;
 use crate::RequestData;
+use std::time::Duration;
 
 /// Trait for executing HTTP requests to selenium/webdriver.
 /// As long as you have some struct that implements WebDriverHttpClientAsync
@@ -19,5 +20,7 @@ pub trait WebDriverHttpClientAsync: Debug + Send + Sync {
     where
         Self: Sized;
 
+    fn set_request_timeout(&mut self, timeout: Duration);
+
     async fn execute(&self, request_data: RequestData) -> WebDriverResult<serde_json::Value>;
 }

src/http/nulldriver_async.rs

@@ -19,6 +19,8 @@ impl WebDriverHttpClientAsync for NullDriverAsync {
         })
     }
 
+    fn set_request_timeout(&mut self, timeout: Duration) {}
+
     async fn execute(&self, _request_data: RequestData) -> WebDriverResult<serde_json::Value> {
         Ok(serde_json::Value::Null)
     }

src/http/reqwest_async.rs

@@ -8,12 +8,14 @@ use crate::{
     error::{WebDriverError, WebDriverResult},
     RequestData, RequestMethod,
 };
+use std::time::Duration;
 
 /// Asynchronous http to the remote WebDriver server.
 #[derive(Debug)]
 pub struct ReqwestDriverAsync {
     url: String,
     client: reqwest::Client,
+    timeout: Duration,
 }
 
 #[async_trait]
@@ -23,9 +25,14 @@ impl WebDriverHttpClientAsync for ReqwestDriverAsync {
         Ok(ReqwestDriverAsync {
             url: remote_server_addr.trim_end_matches('/').to_owned(),
             client: reqwest::Client::builder().default_headers(headers).build()?,
+            timeout: Duration::from_secs(120),
         })
     }
 
+    fn set_request_timeout(&mut self, timeout: Duration) {
+        self.timeout = timeout;
+    }
+
     /// Execute the specified command and return the data as serde_json::Value.
     async fn execute(&self, request_data: RequestData) -> WebDriverResult<serde_json::Value> {
         let url = self.url.clone() + &request_data.url;
@@ -34,6 +41,8 @@ impl WebDriverHttpClientAsync for ReqwestDriverAsync {
             RequestMethod::Post => self.client.post(&url),
             RequestMethod::Delete => self.client.delete(&url),
         };
+        request = request.timeout(self.timeout);
+
         if let Some(x) = request_data.body {
             request = request.json(&x);
         }

src/http/surf_async.rs

@@ -7,23 +7,39 @@ use crate::{
     error::{WebDriverError, WebDriverResult},
     RequestData, RequestMethod,
 };
+use isahc::prelude::Configurable;
+use std::time::Duration;
+use surf::Client;
 
 /// Asynchronous http to the remote WebDriver server.
 #[derive(Debug)]
 pub struct SurfDriverAsync {
     url: String,
-    client: surf::Client,
+    client: Client,
+}
+
+fn setup_client(timeout: Duration) -> Client {
+    let backing_client =
+        isahc::HttpClient::builder().timeout(timeout).build().expect("Error creating HTTP client");
+    let http_client = http_client::isahc::IsahcClient::from_client(backing_client);
+    Client::with_http_client(http_client)
 }
 
 #[async_trait]
 impl WebDriverHttpClientAsync for SurfDriverAsync {
     fn create(remote_server_addr: &str) -> WebDriverResult<Self> {
         Ok(SurfDriverAsync {
             url: remote_server_addr.trim_end_matches('/').to_owned(),
-            client: surf::Client::new(),
+            client: setup_client(Duration::from_secs(120)),
         })
     }
 
+    fn set_request_timeout(&mut self, timeout: Duration) {
+        // Currently it looks like the only way to increase the timeout is by recreating the client.
+        // https://github.com/http-rs/surf/issues/267
+        self.client = setup_client(timeout);
+    }
+
     /// Execute the specified command and return the data as serde_json::Value.
     async fn execute(&self, request_data: RequestData) -> WebDriverResult<serde_json::Value> {
         let url = self.url.clone() + &request_data.url;

src/session.rs

@@ -9,10 +9,12 @@ use futures::channel::mpsc::{unbounded, UnboundedReceiver, UnboundedSender};
 use futures::channel::oneshot;
 use futures::SinkExt;
 use futures::StreamExt;
+use std::time::Duration;
 
 #[derive(Debug)]
 pub enum SessionMessage {
     Request(RequestData, oneshot::Sender<WebDriverResult<serde_json::Value>>),
+    SetRequestTimeout(Duration),
 }
 
 pub fn spawn_session_task(
@@ -35,7 +37,7 @@ pub fn spawn_session_task(
 
 async fn session_runner(
     mut rx: UnboundedReceiver<SessionMessage>,
-    conn: Box<dyn WebDriverHttpClientAsync>,
+    mut conn: Box<dyn WebDriverHttpClientAsync>,
 ) {
     // This will return None when the sender hangs up.
     while let Some(msg) = rx.next().await {
@@ -44,6 +46,9 @@ async fn session_runner(
                 let ret = conn.execute(data).await;
                 tx.send(ret).expect("Failed to send response");
             }
+            SessionMessage::SetRequestTimeout(timeout) => {
+                conn.set_request_timeout(timeout);
+            }
         }
     }
 }
@@ -96,6 +101,13 @@ impl WebDriverSession {
             )),
         }
     }
+
+    pub async fn set_request_timeout(&mut self, timeout: Duration) -> WebDriverResult<()> {
+        self.tx.clone().send(SessionMessage::SetRequestTimeout(timeout)).await.map_err(|e| {
+            WebDriverError::UnknownResponse(format!("Failed to send request to server: {}", e))
+        })?;
+        Ok(())
+    }
 }
 
 #[async_trait]

src/webdriver.rs

@@ -19,6 +19,7 @@ use crate::{
     DesiredCapabilities, SessionId,
 };
 use futures::executor::block_on;
+use std::time::Duration;
 
 #[cfg(not(any(feature = "tokio-runtime", feature = "async-std-runtime")))]
 /// The WebDriver struct represents a browser session.
@@ -141,6 +142,27 @@ where
     pub fn config_mut(&mut self) -> &mut WebDriverConfig {
         self.session.config_mut()
     }
+
+    /// Set the request timeout for the HTTP client.
+    ///
+    /// # Example
+    /// ```rust
+    /// # use thirtyfour::prelude::*;
+    /// # use std::time::Duration;
+    /// # use thirtyfour::support::block_on;
+    /// #
+    /// # fn main() -> WebDriverResult<()> {
+    /// #     block_on(async {
+    /// let caps = DesiredCapabilities::chrome();
+    /// let mut driver = WebDriver::new("http://localhost:4444/wd/hub", &caps).await?;
+    /// driver.set_request_timeout(Duration::from_secs(180)).await?;
+    /// #         Ok(())
+    /// #     })
+    /// # }
+    /// ```
+    pub async fn set_request_timeout(&mut self, timeout: Duration) -> WebDriverResult<()> {
+        self.session.set_request_timeout(timeout).await
+    }
 }
 
 #[async_trait]

src/webdrivercommands.rs

@@ -774,6 +774,10 @@ pub trait WebDriverCommands {
 
     /// Set all timeouts for the current session.
     ///
+    /// NOTE: If you set timeouts to values greater than 120 seconds,
+    ///       remember to also increase the request timeout.
+    ///       See `WebDriver::set_request_timeout()` for more details.
+    ///
     /// # Example:
     /// ```rust
     /// # use thirtyfour::prelude::*;
@@ -807,6 +811,10 @@ pub trait WebDriverCommands {
     /// find it more reliable to set the implicit wait time to 0 (no wait)
     /// and implement your own polling loop outside of `thirtyfour`.
     ///
+    /// NOTE: If you set timeouts to values greater than 120 seconds,
+    ///       remember to also increase the request timeout.
+    ///       See `WebDriver::set_request_timeout()` for more details.
+    ///
     /// # Example:
     /// ```rust
     /// # use thirtyfour::prelude::*;
@@ -836,6 +844,10 @@ pub trait WebDriverCommands {
     ///
     /// By default this is set to 60 seconds.
     ///
+    /// NOTE: If you set timeouts to values greater than 120 seconds,
+    ///       remember to also increase the request timeout.
+    ///       See `WebDriver::set_request_timeout()` for more details.
+    ///
     /// # Example:
     /// ```rust
     /// # use thirtyfour::prelude::*;
@@ -865,6 +877,10 @@ pub trait WebDriverCommands {
     ///
     /// By default this is set to 60 seconds.
     ///
+    /// NOTE: If you set timeouts to values greater than 120 seconds,
+    ///       remember to also increase the request timeout.
+    ///       See `WebDriver::set_request_timeout()` for more details.
+    ///
     /// # Example:
     /// ```rust
     /// # use thirtyfour::prelude::*;