Add TransportErrorKind::ProxyError

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

Author: eval-exec

tentacle/src/error.rs

@@ -9,6 +9,9 @@ pub enum TransportErrorKind {
     /// IO error
     #[error("transport io error: `{0:?}`")]
     Io(#[from] IOError),
+    /// Proxy server error
+    #[error("proxy error: `{0:?}`")]
+    ProxyError(IOError),
     /// Protocol not support
     #[error("multiaddr `{0:?}` is not supported")]
     NotSupported(Multiaddr),

tentacle/src/runtime/tokio_runtime/mod.rs

@@ -154,11 +154,17 @@ where
     let socks5_config = socks5_config::parse(&proxy_url, onion_random_socks_auth)?;
 
     let dial_addr: SocketAddr = socks5_config.proxy_url.parse().map_err(io::Error::other)?;
-    let stream = connect_direct(dial_addr, socket_transformer).await?;
+    let stream = connect_direct(dial_addr, socket_transformer)
+        .await
+        .map_err(|err| {
+            io::Error::other(format!("connect to proxy:{}, failed: {:?}", dial_addr, err))
+        })?;
 
     super::proxy::socks5::establish_connection(stream, target_addr, socks5_config)
         .await
-        .map_err(io::Error::other)
+        .map_err(|err| {
+            io::Error::other(format!("failed to establish connection to target:{}", err))
+        })
 }
 
 pub(crate) async fn connect(
@@ -174,7 +180,14 @@ pub(crate) async fn connect(
 
     match proxy_url {
         Some(proxy_url) => {
-            connect_by_proxy(target_addr, socket_transformer, proxy_url, false).await
+            connect_by_proxy(target_addr, socket_transformer, proxy_url.clone(), false)
+                .await
+                .map_err(|err| {
+                    io::Error::new(
+                        io::ErrorKind::Other,
+                        format!("connect_by_proxy: {}, error: {}", proxy_url, err),
+                    )
+                })
         }
         None => connect_direct(target_addr, socket_transformer).await,
     }

tentacle/src/transports/mod.rs

@@ -445,7 +445,13 @@ mod os {
     ) -> Result<TcpStream> {
         match crate::runtime::timeout(timeout, crate::runtime::connect(addr, tcp_config)).await {
             Err(_) => Err(TransportErrorKind::Io(io::ErrorKind::TimedOut.into())),
-            Ok(res) => res.map_err(Into::into),
+            Ok(res) => res.map_err(|err| {
+                if err.to_string().contains("connect_by_proxy") {
+                    TransportErrorKind::ProxyError(err)
+                } else {
+                    err.into()
+                }
+            }),
         }
     }
 
@@ -463,7 +469,13 @@ mod os {
         .await
         {
             Err(_) => Err(TransportErrorKind::Io(io::ErrorKind::TimedOut.into())),
-            Ok(res) => res.map_err(Into::into),
+            Ok(res) => res.map_err(|err| {
+                if err.to_string().contains("connect_by_proxy") {
+                    TransportErrorKind::ProxyError(err)
+                } else {
+                    err.into()
+                }
+            }),
         }
     }
 }