Merge pull request #410 from eval-exec/exec/onion_timeout

Add new struct `ServiceConfig{timeout, onion_timeout}` to `ServiceConfig`

Author: driftluo

tentacle/src/builder.rs

@@ -83,9 +83,17 @@ where
 
     /// Timeout for handshake and connect
     ///
-    /// Default 10 second
+    /// Default timeout is 10 second
     pub fn timeout(mut self, timeout: Duration) -> Self {
-        self.config.timeout = timeout;
+        self.config.timeout.timeout = timeout;
+        self
+    }
+
+    /// Onion Timeout for handshake and connect
+    ///
+    /// Default onion_timeout is 120 second
+    pub fn onion_timeout(mut self, onion_timeout: Duration) -> Self {
+        self.config.timeout.onion_timeout = onion_timeout;
         self
     }
 

tentacle/src/service.rs

@@ -170,7 +170,7 @@ where
                 handshake_type,
                 multi_transport: {
                     #[cfg(target_family = "wasm")]
-                    let transport = MultiTransport::new(config.timeout);
+                    let transport = MultiTransport::new(config.timeout.timeout);
                     #[allow(clippy::let_and_return)]
                     #[cfg(not(target_family = "wasm"))]
                     let transport = MultiTransport::new(config.timeout, config.tcp_config.clone());
@@ -319,7 +319,7 @@ where
             handshake_type: self.handshake_type.clone(),
             event_sender: self.session_event_sender.clone(),
             max_frame_length: self.config.max_frame_length,
-            timeout: self.config.timeout,
+            timeout: self.config.timeout.timeout,
             listen_addr: listen_address,
             future_task_sender: self.future_task_sender.clone(),
             listens_upgrade_modes: self.multi_transport.listens_upgrade_modes.clone(),
@@ -373,7 +373,7 @@ where
         self.dial_protocols.insert(address.clone(), target);
 
         let handshake_type = self.handshake_type.clone();
-        let timeout = self.config.timeout;
+        let timeout = self.config.timeout.timeout;
         let max_frame_length = self.config.max_frame_length;
 
         let mut sender = self.session_event_sender.clone();
@@ -553,7 +553,7 @@ where
             handshake_type: self.handshake_type.clone(),
             event_sender: self.session_event_sender.clone(),
             max_frame_length: self.config.max_frame_length,
-            timeout: self.config.timeout,
+            timeout: self.config.timeout.timeout,
         }
         .handshake(socket);
 
@@ -692,7 +692,7 @@ where
         });
 
         let meta = SessionMeta::new(
-            self.config.timeout,
+            self.config.timeout.timeout,
             session_context.clone(),
             service_event_sender,
             self.service_context.control().clone(),

tentacle/src/service/config.rs

@@ -20,8 +20,23 @@ use tokio_rustls::rustls::{ClientConfig, ServerConfig};
 /// Default max buffer size
 const MAX_BUF_SIZE: usize = 24 * 1024 * 1024;
 
-pub(crate) struct ServiceConfig {
+#[derive(Clone, Copy)]
+pub(crate) struct ServiceTimeout {
     pub timeout: Duration,
+    pub onion_timeout: Duration,
+}
+
+impl Default for ServiceTimeout {
+    fn default() -> Self {
+        ServiceTimeout {
+            timeout: Duration::from_secs(10),
+            onion_timeout: Duration::from_secs(120),
+        }
+    }
+}
+
+pub(crate) struct ServiceConfig {
+    pub timeout: ServiceTimeout,
     pub session_config: SessionConfig,
     pub max_frame_length: usize,
     pub keep_buffer: bool,
@@ -36,7 +51,7 @@ pub(crate) struct ServiceConfig {
 impl Default for ServiceConfig {
     fn default() -> Self {
         ServiceConfig {
-            timeout: Duration::from_secs(10),
+            timeout: ServiceTimeout::default(),
             session_config: SessionConfig::default(),
             max_frame_length: 1024 * 1024 * 8,
             keep_buffer: false,

tentacle/src/transports/mod.rs

@@ -93,7 +93,7 @@ mod os {
 
     use crate::{
         runtime::{TcpListener, TcpStream},
-        service::config::TcpConfig,
+        service::config::{ServiceTimeout, TcpConfig},
     };
 
     use futures::{FutureExt, StreamExt, prelude::Stream};
@@ -136,15 +136,15 @@ mod os {
 
     #[derive(Clone)]
     pub(crate) struct MultiTransport {
-        pub(crate) timeout: Duration,
+        pub(crate) timeout: ServiceTimeout,
         pub(crate) tcp_config: TcpConfig,
         pub(crate) listens_upgrade_modes: Arc<crate::lock::Mutex<HashMap<SocketAddr, UpgradeMode>>>,
         #[cfg(feature = "tls")]
         pub(crate) tls_config: Option<TlsConfig>,
     }
 
     impl MultiTransport {
-        pub fn new(timeout: Duration, tcp_config: TcpConfig) -> Self {
+        pub fn new(timeout: ServiceTimeout, tcp_config: TcpConfig) -> Self {
             MultiTransport {
                 timeout,
                 tcp_config,
@@ -217,20 +217,23 @@ mod os {
         fn dial(self, address: Multiaddr) -> Result<Self::DialFuture> {
             match find_type(&address) {
                 TransportType::Tcp => {
-                    match TcpTransport::new(self.timeout, self.tcp_config.tcp).dial(address) {
+                    match TcpTransport::new(self.timeout.timeout, self.tcp_config.tcp).dial(address)
+                    {
                         Ok(res) => Ok(MultiDialFuture::Tcp(res)),
                         Err(e) => Err(e),
                     }
                 }
                 TransportType::Onion => {
-                    match OnionTransport::new(self.timeout, self.tcp_config.tcp).dial(address) {
+                    match OnionTransport::new(self.timeout.onion_timeout, self.tcp_config.tcp)
+                        .dial(address)
+                    {
                         Ok(res) => Ok(MultiDialFuture::Tcp(res)),
                         Err(e) => Err(e),
                     }
                 }
                 #[cfg(feature = "ws")]
                 TransportType::Ws => {
-                    match WsTransport::new(self.timeout, self.tcp_config.ws).dial(address) {
+                    match WsTransport::new(self.timeout.timeout, self.tcp_config.ws).dial(address) {
                         Ok(future) => Ok(MultiDialFuture::Ws(future)),
                         Err(e) => Err(e),
                     }
@@ -247,7 +250,7 @@ mod os {
                     let tls_config = self.tls_config.ok_or_else(|| {
                         TransportErrorKind::TlsError("tls config is not set".to_string())
                     })?;
-                    TlsTransport::new(self.timeout, tls_config, self.tcp_config.tls)
+                    TlsTransport::new(self.timeout.timeout, tls_config, self.tcp_config.tls)
                         .dial(address)
                         .map(MultiDialFuture::Tls)
                 }

tentacle/src/transports/tcp.rs

@@ -62,7 +62,7 @@ impl TcpTransport {
         listen_mode: TcpListenMode,
     ) -> Self {
         Self {
-            timeout: multi_transport.timeout,
+            timeout: multi_transport.timeout.timeout,
             tcp_config: match listen_mode {
                 TcpListenMode::Tcp => multi_transport.tcp_config.tcp,
                 #[cfg(feature = "ws")]