Service name is static

Author: fafhrd91

ntex-net/src/connect/service.rs

@@ -92,6 +92,7 @@ impl<T: Address> ConnectorService<T> {
             )))
         })
         .and_then(|item| item)
+        .map_err(|e| e.set_service(self.shared.service()))
     }
 }
 

ntex-tls/examples/webclient.rs

@@ -1,9 +1,9 @@
-use ntex::SharedCfg;
-use ntex::client::{Client, Connector, error::SendRequestError};
+use ntex::client::{Client, Connector, error::ClientError};
+use ntex::{SharedCfg, error::Error};
 use tls_openssl::ssl::{self, SslMethod, SslVerifyMode};
 
 #[ntex::main]
-async fn main() -> Result<(), SendRequestError> {
+async fn main() -> Result<(), Error<ClientError>> {
     env_logger::init();
     println!("Connecting to openssl webserver: 127.0.0.1:8443");
 

ntex-tls/src/openssl/connect.rs

@@ -76,39 +76,35 @@ where
         let tag = io.tag();
         log::trace!("{tag}: SSL Handshake start for: {host:?}");
 
-        match self.openssl.configure() {
-            Err(e) => Err(ConnectError::from(io::Error::new(
-                io::ErrorKind::InvalidInput,
-                e,
-            ))
-            .into()),
-            Ok(config) => {
-                let ssl = config.into_ssl(&host).map_err(|e| {
-                    ConnectError::from(io::Error::new(io::ErrorKind::InvalidInput, e))
-                })?;
-
-                match timeout_checked(self.cfg.handshake_timeout(), connect_io(io, ssl))
-                    .await
-                {
-                    Ok(Ok(io)) => {
-                        log::trace!("{tag}: SSL Handshake success: {host:?}");
-                        Ok(io)
-                    }
-                    Ok(Err(e)) => {
-                        log::trace!("{tag}: SSL Handshake error: {e:?}");
-                        Err(ConnectError::from(e).into())
-                    }
-                    Err(()) => {
-                        log::trace!("{tag}: SSL Handshake timeout");
-                        Err(ConnectError::from(io::Error::new(
-                            io::ErrorKind::TimedOut,
-                            "SSL Handshake timeout",
-                        ))
-                        .into())
-                    }
+        async {
+            let config = self.openssl.configure().map_err(|e| {
+                ConnectError::from(io::Error::new(io::ErrorKind::InvalidInput, e))
+            })?;
+            let ssl = config.into_ssl(&host).map_err(|e| {
+                ConnectError::from(io::Error::new(io::ErrorKind::InvalidInput, e))
+            })?;
+
+            match timeout_checked(self.cfg.handshake_timeout(), connect_io(io, ssl)).await {
+                Ok(Ok(io)) => {
+                    log::trace!("{tag}: SSL Handshake success: {host:?}");
+                    Ok(io)
+                }
+                Ok(Err(e)) => {
+                    log::trace!("{tag}: SSL Handshake error: {e:?}");
+                    Err(ConnectError::from(e).into())
+                }
+                Err(()) => {
+                    log::trace!("{tag}: SSL Handshake timeout");
+                    Err(ConnectError::from(io::Error::new(
+                        io::ErrorKind::TimedOut,
+                        "SSL Handshake timeout",
+                    ))
+                    .into())
                 }
             }
         }
+        .await
+        .map_err(|e: Error<_>| e.set_service(self.cfg.service()))
     }
 }
 

ntex-tls/src/rustls/connect.rs

@@ -108,28 +108,33 @@ where
         log::trace!("{tag}: TLS Handshake start for: {host:?}");
 
         let config = self.config.clone();
-        let host = ServerName::try_from(host)
-            .map_err(|e| ConnectError::from(io::Error::other(e)))?;
-
-        let connect_fut = TlsClientFilter::create(io, config, host.clone());
-        match timeout_checked(self.cfg.handshake_timeout(), connect_fut).await {
-            Ok(Ok(io)) => {
-                log::trace!("{tag}: TLS Handshake success: {host:?}");
-                Ok(io)
-            }
-            Ok(Err(e)) => {
-                log::trace!("{tag}: TLS Handshake error: {e:?}");
-                Err(ConnectError::from(e).into())
-            }
-            Err(()) => {
-                log::trace!("{tag}: TLS Handshake timeout");
-                Err(ConnectError::from(io::Error::new(
-                    io::ErrorKind::TimedOut,
-                    "SSL Handshake timeout",
-                ))
-                .into())
+
+        async {
+            let host = ServerName::try_from(host)
+                .map_err(|e| ConnectError::from(io::Error::other(e)))?;
+
+            let connect_fut = TlsClientFilter::create(io, config, host.clone());
+            match timeout_checked(self.cfg.handshake_timeout(), connect_fut).await {
+                Ok(Ok(io)) => {
+                    log::trace!("{tag}: TLS Handshake success: {host:?}");
+                    Ok(io)
+                }
+                Ok(Err(e)) => {
+                    log::trace!("{tag}: TLS Handshake error: {e:?}");
+                    Err(ConnectError::from(e).into())
+                }
+                Err(()) => {
+                    log::trace!("{tag}: TLS Handshake timeout");
+                    Err(ConnectError::from(io::Error::new(
+                        io::ErrorKind::TimedOut,
+                        "SSL Handshake timeout",
+                    ))
+                    .into())
+                }
             }
         }
+        .await
+        .map_err(|e: Error<_>| e.set_service(self.cfg.service()))
     }
 }
 

ntex/CHANGES.md

@@ -1,5 +1,9 @@
 # Changes
 
+## [3.6.0] - 2026-03-xx
+
+* Use ntex_error::Error for http client
+
 ## [3.5.1] - 2026-02-19
 
 * Fix http client request version

ntex/examples/client.rs

@@ -1,7 +1,7 @@
-use ntex::client::{Client, error::SendRequestError};
+use ntex::{client::Client, client::error::ClientError, error::Error};
 
 #[ntex::main]
-async fn main() -> Result<(), SendRequestError> {
+async fn main() -> Result<(), Error<ClientError>> {
     env_logger::init();
 
     let client = Client::new().await;

ntex/src/client/builder.rs

@@ -5,9 +5,9 @@ use base64::{Engine, engine::general_purpose::STANDARD as base64};
 use crate::http::error::HttpError;
 use crate::http::header::{self, HeaderName, HeaderValue};
 use crate::service::{Identity, Middleware, Service, ServiceFactory, Stack, boxed};
-use crate::{SharedCfg, time::Millis};
+use crate::{SharedCfg, error::Error, time::Millis};
 
-use super::error::{ClientBuilderError, SendRequestError};
+use super::error::{ClientBuilderError, ClientError};
 use super::sender::Sender;
 use super::service::{ServiceRequest, ServiceResponse};
 use super::{Client, ClientConfig, Connector, cfg::ClientConfigInner};
@@ -202,7 +202,7 @@ impl<M> ClientBuilder<M> {
     where
         T: Into<SharedCfg>,
         M: Middleware<Sender, ClientConfig>,
-        M::Service: Service<ServiceRequest, Response = ServiceResponse, Error = SendRequestError>
+        M::Service: Service<ServiceRequest, Response = ServiceResponse, Error = Error<ClientError>>
             + 'static,
     {
         let cfg = cfg.into();

ntex/src/client/connection.rs

@@ -5,7 +5,7 @@ use crate::http::{Payload, ResponseHead, Version};
 use crate::io::{IoBoxed, types::HttpProtocol};
 use crate::time::Millis;
 
-use super::{ClientRawRequest, error::SendRequestError, h1proto, h2proto, pool::Acquired};
+use super::{ClientRawRequest, error::ClientError, h1proto, h2proto, pool::Acquired};
 
 pub(super) enum ConnectionType {
     H1(IoBoxed),
@@ -93,7 +93,7 @@ impl Connection {
         mut req: ClientRawRequest,
         body: Body,
         timeout: Millis,
-    ) -> Result<(ResponseHead, Payload), SendRequestError> {
+    ) -> Result<(ResponseHead, Payload), ClientError> {
         match self.io.take().unwrap() {
             ConnectionType::H1(io) => {
                 req.head.version = Version::HTTP_11;

ntex/src/client/connector.rs

@@ -4,7 +4,8 @@ use crate::connect::{Connect as TcpConnect, Connector as TcpConnector};
 use crate::service::{Service, ServiceCtx, ServiceFactory, apply_fn_factory, boxed};
 use crate::{SharedCfg, error::Error, http::Uri, io::IoBoxed, time::Seconds, util::join};
 
-use super::{Connect, Connection, error::ConnectError, pool::ConnectionPool};
+use super::error::{ClientError, ConnectError};
+use super::{Connect, Connection, pool::ConnectionPool};
 
 #[cfg(feature = "openssl")]
 use tls_openssl::ssl::SslConnector as OpensslConnector;
@@ -197,7 +198,7 @@ impl Connector {
 
 impl ServiceFactory<Connect, SharedCfg> for Connector {
     type Response = Connection;
-    type Error = Error<ConnectError>;
+    type Error = Error<ClientError>;
     type Service = ConnectorService;
     type InitError = Box<dyn StdError>;
 
@@ -218,39 +219,44 @@ impl ServiceFactory<Connect, SharedCfg> for Connector {
             self.conn_lifetime,
             self.conn_keep_alive,
             self.limit,
-            cfg,
+            cfg.clone(),
         );
-        Ok(ConnectorService { tcp_pool, ssl_pool })
+        Ok(ConnectorService {
+            cfg,
+            tcp_pool,
+            ssl_pool,
+        })
     }
 }
 
 /// Manages http client network connectivity.
 #[derive(Clone, Debug)]
 pub struct ConnectorService {
+    cfg: SharedCfg,
     tcp_pool: ConnectionPool,
     ssl_pool: Option<ConnectionPool>,
 }
 
 impl Service<Connect> for ConnectorService {
     type Response = Connection;
-    type Error = Error<ConnectError>;
+    type Error = Error<ClientError>;
 
     #[inline]
     async fn ready(&self, ctx: ServiceCtx<'_, Self>) -> Result<(), Self::Error> {
         if let Some(ref ssl_pool) = self.ssl_pool {
             let (r1, r2) = join(ctx.ready(&self.tcp_pool), ctx.ready(ssl_pool)).await;
-            r1?;
-            r2
+            r1.map_err(ClientError::from)?;
+            Ok(r2.map_err(ClientError::from)?)
         } else {
-            ctx.ready(&self.tcp_pool).await
+            Ok(ctx.ready(&self.tcp_pool).await.map_err(ClientError::from)?)
         }
     }
 
     #[inline]
     fn poll(&self, cx: &mut Context<'_>) -> Result<(), Self::Error> {
-        self.tcp_pool.poll(cx)?;
+        self.tcp_pool.poll(cx).map_err(ClientError::from)?;
         if let Some(ref ssl_pool) = self.ssl_pool {
-            ssl_pool.poll(cx)?;
+            ssl_pool.poll(cx).map_err(ClientError::from)?;
         }
         Ok(())
     }
@@ -270,13 +276,20 @@ impl Service<Connect> for ConnectorService {
         match req.uri.scheme_str() {
             Some("https" | "wss") => {
                 if let Some(ref conn) = self.ssl_pool {
-                    ctx.call(conn, req).await
+                    ctx.call(conn, req).await.map_err(ClientError::from)
                 } else {
-                    Err(ConnectError::SslIsNotSupported.into())
+                    Err(ClientError::from(
+                        Error::from(ConnectError::SslIsNotSupported)
+                            .set_service(self.cfg.service()),
+                    ))
                 }
             }
-            _ => ctx.call(&self.tcp_pool, req).await,
+            _ => ctx
+                .call(&self.tcp_pool, req)
+                .await
+                .map_err(ClientError::from),
         }
+        .map_err(Error::from)
     }
 }
 

ntex/src/client/error.rs

@@ -143,7 +143,7 @@ pub enum InvalidUrl {
 
 /// A set of errors that can occur during request sending and response reading
 #[derive(thiserror::Error, Debug)]
-pub enum SendRequestError {
+pub enum ClientError {
     /// Invalid URL
     #[error("Invalid URL: {0}")]
     Url(#[from] InvalidUrl),
@@ -176,39 +176,63 @@ pub enum SendRequestError {
     Error(#[from] Rc<dyn StdError>),
 }
 
-impl Clone for SendRequestError {
-    fn clone(&self) -> SendRequestError {
+impl ErrorDiagnostic for ClientError {
+    type Kind = ErrorType;
+
+    fn kind(&self) -> ErrorType {
         match self {
-            SendRequestError::Url(err) => SendRequestError::Url(err.clone()),
-            SendRequestError::Connect(err) => SendRequestError::Connect(err.clone()),
-            SendRequestError::Request(err) => SendRequestError::Request(err.clone()),
-            SendRequestError::Response(err) => SendRequestError::Response(*err),
-            SendRequestError::Http(err) => SendRequestError::Http(err.clone()),
-            SendRequestError::H2(err) => SendRequestError::H2(err.clone()),
-            SendRequestError::Timeout => SendRequestError::Timeout,
-            SendRequestError::TunnelNotSupported => SendRequestError::TunnelNotSupported,
-            SendRequestError::Error(err) => SendRequestError::Error(err.clone()),
-            SendRequestError::Send(err) => {
-                SendRequestError::Send(crate::util::clone_io_error(err))
-            }
+            ClientError::Url(_) | ClientError::Http(_) => ErrorType::ClientError,
+            ClientError::Connect(err) => err.kind(),
+            ClientError::Send(_)
+            | ClientError::Request(_)
+            | ClientError::Response(_)
+            | ClientError::H2(_)
+            | ClientError::Timeout
+            | ClientError::TunnelNotSupported
+            | ClientError::Error(_) => ErrorType::ServiceError,
+        }
+    }
+
+    fn service(&self) -> Option<&'static str> {
+        if let ClientError::Connect(err) = self {
+            err.service()
+        } else {
+            None
         }
     }
 }
 
-impl From<Either<EncodeError, io::Error>> for SendRequestError {
+impl Clone for ClientError {
+    fn clone(&self) -> ClientError {
+        match self {
+            ClientError::Url(err) => ClientError::Url(err.clone()),
+            ClientError::Connect(err) => ClientError::Connect(err.clone()),
+            ClientError::Request(err) => ClientError::Request(err.clone()),
+            ClientError::Response(err) => ClientError::Response(*err),
+            ClientError::Http(err) => ClientError::Http(err.clone()),
+            ClientError::H2(err) => ClientError::H2(err.clone()),
+            ClientError::Timeout => ClientError::Timeout,
+            ClientError::TunnelNotSupported => ClientError::TunnelNotSupported,
+            ClientError::Error(err) => ClientError::Error(err.clone()),
+            ClientError::Send(err) => ClientError::Send(crate::util::clone_io_error(err)),
+        }
+    }
+}
+
+impl From<Either<EncodeError, io::Error>> for ClientError {
     fn from(err: Either<EncodeError, io::Error>) -> Self {
         match err {
-            Either::Left(err) => SendRequestError::Request(err),
-            Either::Right(err) => SendRequestError::Send(err),
+            Either::Left(err) => ClientError::Request(err),
+            Either::Right(err) => ClientError::Send(err),
         }
     }
 }
 
-impl From<Either<DecodeError, io::Error>> for SendRequestError {
+impl From<Either<DecodeError, io::Error>> for ClientError {
     fn from(err: Either<DecodeError, io::Error>) -> Self {
         match err {
-            Either::Left(err) => SendRequestError::Response(err),
-            Either::Right(err) => SendRequestError::Send(err),
+            Either::Left(err) => ClientError::Response(err),
+            Either::Right(err) => ClientError::Send(err),
         }
     }
 }
@@ -218,3 +242,7 @@ impl From<ClientBuilderError> for io::Error {
         io::Error::other(err)
     }
 }
+
+#[doc(hidden)]
+#[deprecated(since = "3.6.0", note = "Use ntex::client::error::ClientError instead")]
+pub type SendRequestError = ClientError;