Use ntex-error::Error (#84)

Author: fafhrd91

CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changes
 
+## [3.8.0] - 2026-03-07
+
+* Use ntex-error::Error
+
 ## [3.7.1] - 2026-02-16
 
 * ServiceConfig is not Clone

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ntex-h2"
-version = "3.7.1"
+version = "3.8.0"
 license = "MIT OR Apache-2.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "An HTTP/2 client and server"
@@ -27,11 +27,12 @@ ntex-bytes = "1.5"
 ntex-codec = "1.1"
 ntex-dispatcher = "3"
 ntex-http = "1"
-ntex-io = "3.7"
-ntex-net = "3"
-ntex-service = "4.4"
+ntex-io = "3.9"
+ntex-net = "3.8"
+ntex-service = "4.6"
 ntex-util = "3"
-ntex-server = "3.7"
+ntex-server = "3.9"
+ntex-error = "1.0"
 
 bitflags = "2"
 foldhash = "0.2"
@@ -51,8 +52,8 @@ walkdir = "2.3.2"
 serde = "1"
 serde_json = "1"
 
-ntex = { version = "3.2", features = ["openssl"] }
-ntex-tls = { version = "3", features = ["openssl"] }
+ntex = { version = "3.6", features = ["openssl"] }
+ntex-tls = { version = "3.4", features = ["openssl"] }
 openssl = "0.10"
 
 # Examples

examples/client.rs

@@ -17,7 +17,7 @@ pub async fn main() -> Result<(), Box<dyn Error>> {
 
     let pool = client::Client::builder(
         "127.0.0.1:5928",
-        ntex_tls::openssl::SslConnector::new(builder.build()),
+        ntex_tls::openssl::SslConnector2::new(builder.build()),
     )
     .scheme(Scheme::HTTPS)
     .build(SharedCfg::default())

examples/server.rs

@@ -1,4 +1,5 @@
 use ntex::service::{cfg::SharedCfg, fn_service};
+use ntex_error::Error;
 use ntex_h2::{Control, Message, MessageKind, OperationError, ServiceConfig, server};
 use ntex_http::{HeaderMap, StatusCode, header};
 use ntex_util::time::{Millis, sleep};
@@ -49,7 +50,7 @@ async fn main() -> std::io::Result<()> {
                         log::trace!("Disconnect: {:?}", err);
                     }
                 }
-                Ok::<_, OperationError>(())
+                Ok::<_, Error<OperationError>>(())
             }))
             .control(|msg: Control<_>| async move {
                 log::trace!("Control message: {:?}", msg);

examples/tls-server.rs

@@ -1,4 +1,5 @@
 use ntex::service::{ServiceFactory, fn_service};
+use ntex_error::Error;
 use ntex_h2::{Control, Message, MessageKind, OperationError, server};
 use ntex_http::{HeaderMap, StatusCode, header};
 use ntex_tls::openssl::SslAcceptor;
@@ -71,7 +72,7 @@ async fn main() -> std::io::Result<()> {
                                 log::trace!("Disconnect: {:?}", err);
                             }
                         }
-                        Ok::<_, OperationError>(())
+                        Ok::<_, Error<OperationError>>(())
                     }))
                     .control(|msg: Control<_>| async move {
                         println!("Control message: {:?}", msg);

src/client/connector.rs

@@ -1,9 +1,10 @@
 use std::marker::PhantomData;
 
 use ntex_bytes::ByteString;
+use ntex_error::Error;
 use ntex_http::uri::Scheme;
 use ntex_io::IoBoxed;
-use ntex_net::connect::{Address, Connect, ConnectError, Connector as DefaultConnector};
+use ntex_net::connect::{Address, Connect, ConnectError, Connector2 as DefaultConnector};
 use ntex_service::cfg::{Cfg, SharedCfg};
 use ntex_service::{IntoServiceFactory, Service, ServiceCtx, ServiceFactory};
 use ntex_util::{channel::pool, time::timeout_checked};
@@ -24,7 +25,7 @@ pub struct Connector<A: Address, T> {
 impl<A, T> Connector<A, T>
 where
     A: Address,
-    T: ServiceFactory<Connect<A>, SharedCfg, Error = ConnectError>,
+    T: ServiceFactory<Connect<A>, SharedCfg, Error = Error<ConnectError>>,
     IoBoxed: From<T::Response>,
 {
     /// Create new http2 connector
@@ -66,7 +67,7 @@ where
     pub fn connector<U, F>(&self, svc: F) -> Connector<A, U>
     where
         F: IntoServiceFactory<U, Connect<A>, SharedCfg>,
-        U: ServiceFactory<Connect<A>, SharedCfg, Error = ConnectError>,
+        U: ServiceFactory<Connect<A>, SharedCfg, Error = Error<ConnectError>>,
         IoBoxed: From<U::Response>,
     {
         Connector {
@@ -81,11 +82,11 @@ where
 impl<A, T> ServiceFactory<A, SharedCfg> for Connector<A, T>
 where
     A: Address,
-    T: ServiceFactory<Connect<A>, SharedCfg, Error = ConnectError>,
+    T: ServiceFactory<Connect<A>, SharedCfg, Error = Error<ConnectError>>,
     IoBoxed: From<T::Response>,
 {
     type Response = SimpleClient;
-    type Error = ClientError;
+    type Error = Error<ClientError>;
     type InitError = T::InitError;
     type Service = ConnectorService<A, T::Service>;
 
@@ -114,19 +115,24 @@ pub struct ConnectorService<A, T> {
 impl<A, T> Service<A> for ConnectorService<A, T>
 where
     A: Address,
-    T: Service<Connect<A>, Error = ConnectError>,
+    T: Service<Connect<A>, Error = Error<ConnectError>>,
     IoBoxed: From<T::Response>,
 {
     type Response = SimpleClient;
-    type Error = ClientError;
+    type Error = Error<ClientError>;
 
     /// Connect to http2 server
-    async fn call(&self, req: A, ctx: ServiceCtx<'_, Self>) -> Result<SimpleClient, ClientError> {
+    async fn call(&self, req: A, ctx: ServiceCtx<'_, Self>) -> Result<SimpleClient, Self::Error> {
         let authority = ByteString::from(req.host());
 
         let fut = async {
-            Ok::<_, ClientError>(SimpleClient::with_params(
-                ctx.call(&self.svc, Connect::new(req)).await?.into(),
+            let io = ctx
+                .call(&self.svc, Connect::new(req))
+                .await
+                .map_err(|e| e.map(ClientError::from))?;
+
+            Ok::<_, Error<ClientError>>(SimpleClient::with_params(
+                io.into(),
                 self.config.clone(),
                 &self.scheme,
                 authority,
@@ -138,11 +144,13 @@ where
 
         timeout_checked(self.config.handshake_timeout, fut)
             .await
-            .map_err(|()| ClientError::HandshakeTimeout)
+            .map_err(|()| {
+                Error::from(ClientError::HandshakeTimeout).set_service(self.config.service())
+            })
             .and_then(|item| item)
     }
 
-    ntex_service::forward_ready!(svc);
-    ntex_service::forward_poll!(svc);
+    ntex_service::forward_ready!(svc, |e| e.map(ClientError::from));
+    ntex_service::forward_poll!(svc, |e| e.map(ClientError::from));
     ntex_service::forward_shutdown!(svc);
 }

src/client/mod.rs

@@ -1,5 +1,9 @@
 //! Http2 client
-use std::rc::Rc;
+use std::io;
+
+use ntex_error::{ErrorDiagnostic, ErrorType};
+use ntex_net::connect::ConnectError;
+use ntex_util::channel::Canceled;
 
 mod connector;
 mod pool;
@@ -18,7 +22,7 @@ pub use self::stream::{RecvStream, SendStream};
 pub enum ClientError {
     /// Protocol error
     #[error("Protocol error: {0}")]
-    Protocol(Rc<ConnectionError>),
+    Protocol(ConnectionError),
     /// Operation error
     #[error("Operation error: {0}")]
     Operation(#[from] OperationError),
@@ -30,27 +34,21 @@ pub enum ClientError {
     HandshakeTimeout,
     /// Connect error
     #[error("Connect error: {0}")]
-    Connect(Rc<ntex_net::connect::ConnectError>),
+    Connect(#[from] ConnectError),
     /// Peer disconnected
     #[error("Peer disconnected err: {0}")]
-    Disconnected(#[from] std::io::Error),
+    Disconnected(#[from] io::Error),
 }
 
 impl From<ConnectionError> for ClientError {
     fn from(err: ConnectionError) -> Self {
-        Self::Protocol(Rc::new(err))
-    }
-}
-
-impl From<ntex_util::channel::Canceled> for ClientError {
-    fn from(err: ntex_util::channel::Canceled) -> Self {
-        Self::Disconnected(std::io::Error::other(err))
+        Self::Protocol(err)
     }
 }
 
-impl From<ntex_net::connect::ConnectError> for ClientError {
-    fn from(err: ntex_net::connect::ConnectError) -> Self {
-        Self::Connect(Rc::new(err))
+impl From<Canceled> for ClientError {
+    fn from(err: Canceled) -> Self {
+        Self::Disconnected(io::Error::other(err))
     }
 }
 
@@ -63,12 +61,20 @@ impl Clone for ClientError {
             Self::HandshakeTimeout => Self::HandshakeTimeout,
             Self::Connect(err) => Self::Connect(err.clone()),
             Self::Disconnected(err) => {
-                Self::Disconnected(std::io::Error::new(err.kind(), format!("{err}")))
+                Self::Disconnected(io::Error::new(err.kind(), format!("{err}")))
             }
         }
     }
 }
 
+impl ErrorDiagnostic for ClientError {
+    type Kind = ErrorType;
+
+    fn kind(&self) -> Self::Kind {
+        ErrorType::Service
+    }
+}
+
 #[cfg(feature = "unstable")]
 pub trait Observer {
     /// New request is prepared

src/client/pool.rs

@@ -3,9 +3,10 @@ use std::{cell::Cell, cell::RefCell, fmt, marker::PhantomData, rc::Rc, time::Dur
 
 use nanorand::{Rng, WyRand};
 use ntex_bytes::ByteString;
+use ntex_error::Error;
 use ntex_http::{HeaderMap, Method, uri::Scheme};
 use ntex_io::IoBoxed;
-use ntex_net::connect::{Address, Connect, ConnectError, Connector as DefaultConnector};
+use ntex_net::connect::{Address, Connect, ConnectError, Connector2 as DefaultConnector};
 use ntex_service::cfg::{Cfg, SharedCfg};
 use ntex_service::{IntoServiceFactory, Pipeline, ServiceFactory};
 use ntex_util::time::{Millis, Seconds, timeout_checked};
@@ -15,8 +16,8 @@ use super::stream::{InflightStorage, RecvStream, SendStream};
 use super::{ClientError, simple::SimpleClient};
 use crate::ServiceConfig;
 
-type Fut = BoxFuture<'static, Result<IoBoxed, ConnectError>>;
-type Connector = Box<dyn Fn() -> BoxFuture<'static, Result<IoBoxed, ConnectError>>>;
+type Fut = BoxFuture<'static, Result<IoBoxed, Error<ConnectError>>>;
+type Connector = Box<dyn Fn() -> BoxFuture<'static, Result<IoBoxed, Error<ConnectError>>>>;
 
 #[derive(Clone)]
 /// Manages http client network connectivity.
@@ -48,7 +49,7 @@ impl Client {
     where
         A: Address + Clone,
         F: IntoServiceFactory<T, Connect<A>, SharedCfg>,
-        T: ServiceFactory<Connect<A>, SharedCfg, Error = ConnectError> + 'static,
+        T: ServiceFactory<Connect<A>, SharedCfg, Error = Error<ConnectError>> + 'static,
         IoBoxed: From<T::Response>,
         Connect<A>: From<U>,
     {
@@ -62,16 +63,16 @@ impl Client {
         path: ByteString,
         headers: HeaderMap,
         eof: bool,
-    ) -> Result<(SendStream, RecvStream), ClientError> {
+    ) -> Result<(SendStream, RecvStream), Error<ClientError>> {
         self.client()
             .await?
             .send(method, path, headers, eof)
             .await
-            .map_err(From::from)
+            .map_err(|e| e.map(ClientError::from))
     }
 
     /// Get client from the pool
-    pub async fn client(&self) -> Result<SimpleClient, ClientError> {
+    pub async fn client(&self) -> Result<SimpleClient, Error<ClientError>> {
         loop {
             let (client, num) = self.get_client();
 
@@ -82,7 +83,7 @@ impl Client {
         }
     }
 
-    async fn connect(&self, num: usize) -> Result<(), ClientError> {
+    async fn connect(&self, num: usize) -> Result<(), Error<ClientError>> {
         let cfg = &self.inner.config;
 
         // can create new connection
@@ -102,7 +103,8 @@ impl Client {
             // wait for available connection
             let (tx, rx) = cfg.pool.channel();
             self.waiters.borrow_mut().push_back(tx);
-            rx.await?;
+            rx.await
+                .map_err(|e| Error::new(e, self.inner.cfg.service()))?;
         }
         Ok(())
     }
@@ -157,7 +159,7 @@ impl Client {
         }
     }
 
-    async fn create_connection(&self) -> Result<(), ClientError> {
+    async fn create_connection(&self) -> Result<(), Error<ClientError>> {
         let (tx, rx) = oneshot::channel();
 
         let inner = self.inner.clone();
@@ -188,8 +190,8 @@ impl Client {
                         .set(inner.config.total_connections.get() + 1);
                     Ok(())
                 }
-                Ok(Err(err)) => Err(ClientError::from(err)),
-                Err(()) => Err(ClientError::HandshakeTimeout),
+                Ok(Err(err)) => Err(err.map(ClientError::from)),
+                Err(()) => Err(Error::from(ClientError::HandshakeTimeout)),
             };
             inner.config.connecting.set(false);
             for waiter in waiters.borrow_mut().drain(..) {
@@ -205,7 +207,8 @@ impl Client {
             let _ = tx.send(res);
         });
 
-        rx.await?
+        rx.await
+            .map_err(|e| Error::new(e, self.inner.cfg.service()))?
     }
 
     #[inline]
@@ -298,7 +301,7 @@ struct InnerConfig {
 impl<A, T> ClientBuilder<A, T>
 where
     A: Address + Clone,
-    T: ServiceFactory<Connect<A>, SharedCfg, Error = ConnectError>,
+    T: ServiceFactory<Connect<A>, SharedCfg, Error = Error<ConnectError>>,
     IoBoxed: From<T::Response>,
 {
     fn new<U, F>(addr: U, connector: F) -> Self
@@ -412,7 +415,7 @@ where
     pub fn connector<U, F>(self, connector: F) -> ClientBuilder<A, U>
     where
         F: IntoServiceFactory<U, Connect<A>, SharedCfg>,
-        U: ServiceFactory<Connect<A>, SharedCfg, Error = ConnectError> + 'static,
+        U: ServiceFactory<Connect<A>, SharedCfg, Error = Error<ConnectError>> + 'static,
         IoBoxed: From<U::Response>,
     {
         ClientBuilder {
@@ -427,7 +430,7 @@ where
 impl<A, T> ClientBuilder<A, T>
 where
     A: Address + Clone,
-    T: ServiceFactory<Connect<A>, SharedCfg, Error = ConnectError> + 'static,
+    T: ServiceFactory<Connect<A>, SharedCfg, Error = Error<ConnectError>> + 'static,
     IoBoxed: From<T::Response>,
 {
     /// Finish configuration process and create connections pool.