Let onion_dial use onion_timeout

Signed-off-by: Eval EXEC <execvy@gmail.com>

Author: eval-exec

tentacle/src/builder.rs

@@ -1,6 +1,6 @@
 use std::{io, sync::Arc, time::Duration};
 
-use crate::service::config::{ServiceTimeout, TransformerContext};
+use crate::service::config::TransformerContext;
 use nohash_hasher::IntMap;
 use tokio_util::codec::LengthDelimitedCodec;
 
@@ -83,12 +83,17 @@ where
 
     /// Timeout for handshake and connect
     ///
-    /// Default timeout is 10 second, default onion_timeout is 120 second
-    pub fn timeout(mut self, timeout: Duration, onion_timeout: Duration) -> Self {
-        self.config.timeout = ServiceTimeout {
-            timeout,
-            onion_timeout,
-        };
+    /// Default timeout is 10 second
+    pub fn timeout(mut self, timeout: Duration) -> Self {
+        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());
@@ -309,7 +309,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(),
         };
@@ -362,7 +362,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();
@@ -542,7 +542,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);
 
@@ -681,7 +681,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,9 +20,10 @@ use tokio_rustls::rustls::{ClientConfig, ServerConfig};
 /// Default max buffer size
 const MAX_BUF_SIZE: usize = 24 * 1024 * 1024;
 
+#[derive(Clone, Copy)]
 pub(crate) struct ServiceTimeout {
-    timeout: Duration,
-    onion_timeout: Duration,
+    pub timeout: Duration,
+    pub onion_timeout: Duration,
 }
 
 impl Default for ServiceTimeout {

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")]