Use updated Service trait

ntex-rs · Dec 4, 2024 · 681bb77 · 681bb77
1 parent 15008af
commit 681bb77
Show file tree

Hide file tree

Showing 11 changed files with 133 additions and 135 deletions.
diff --git a/CHANGES.md b/CHANGES.md
@@ -1,5 +1,9 @@
 # Changes
 
+## [4.5.0] - 2024-12-04
+
+* Use updated Service trait
+
 ## [4.4.0] - 2024-11-10
 
 * Check service readiness once per decoded item

diff --git a/Cargo.toml b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ntex-mqtt"
-version = "4.4.0"
+version = "4.5.0"
 authors = ["ntex contributors <[email protected]>"]
 description = "Client and Server framework for MQTT v5 and v3.1.1 protocols"
 documentation = "https://docs.rs/ntex-mqtt"
@@ -17,8 +17,8 @@ features = ["ntex/tokio"]
 [dependencies]
 ntex-io = "2"
 ntex-net = "2"
-ntex-util = "2.5"
-ntex-service = "3.3.3"
+ntex-util = "2.8"
+ntex-service = "3.4"
 ntex-bytes = "0.1"
 ntex-codec = "0.6"
 ntex-router = "0.5"

diff --git a/src/inflight.rs b/src/inflight.rs
@@ -2,7 +2,7 @@
 use std::{cell::Cell, future::poll_fn, rc::Rc, task::Context, task::Poll};
 
 use ntex_service::{Middleware, Service, ServiceCtx};
-use ntex_util::{future::join, future::select, task::LocalWaker};
+use ntex_util::{future::join, task::LocalWaker};
 
 /// Trait for types that could be sized
 pub trait SizedRequest {
@@ -83,13 +83,6 @@ where
         }
     }
 
-    #[inline]
-    async fn not_ready(&self) {
-        if self.count.is_available() {
-            select(self.count.unavailable(), self.service.not_ready()).await;
-        }
-    }
-
     #[inline]
     async fn call(&self, req: R, ctx: ServiceCtx<'_, Self>) -> Result<S::Response, S::Error> {
         let size = if self.count.0.max_size > 0 { req.size() } else { 0 };
@@ -99,6 +92,7 @@ where
         result
     }
 
+    ntex_service::forward_poll!(service);
     ntex_service::forward_shutdown!(service);
 }
 
@@ -135,10 +129,6 @@ impl Counter {
     async fn available(&self) {
         poll_fn(|cx| if self.0.available(cx) { Poll::Ready(()) } else { Poll::Pending }).await
     }
-
-    async fn unavailable(&self) {
-        poll_fn(|cx| if self.0.available(cx) { Poll::Pending } else { Poll::Ready(()) }).await
-    }
 }
 
 struct CounterGuard(u32, Rc<CounterInner>);
@@ -305,7 +295,6 @@ mod tests {
         }))
         .bind();
         assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
-        assert_eq!(lazy(|cx| srv.poll_not_ready(cx)).await, Poll::Pending);
 
         let srv2 = srv.clone();
         ntex_util::spawn(async move {

diff --git a/src/io.rs b/src/io.rs
@@ -1,7 +1,6 @@
 //! Framed transport dispatcher
-use std::future::{poll_fn, Future};
 use std::task::{ready, Context, Poll};
-use std::{cell::Cell, cell::RefCell, collections::VecDeque, pin::Pin, rc::Rc};
+use std::{cell::Cell, cell::RefCell, collections::VecDeque, future::Future, pin::Pin, rc::Rc};
 
 use ntex_codec::{Decoder, Encoder};
 use ntex_io::{
@@ -255,12 +254,6 @@ where
             }
         }
 
-        // start ready task
-        if inner.flags.contains(Flags::READY_TASK) {
-            inner.flags.insert(Flags::READY_TASK);
-            ntex_rt::spawn(not_ready(inner.state.clone(), inner.service.clone()));
-        }
-
         loop {
             match inner.st {
                 IoDispatcherState::Processing => {
@@ -595,30 +588,6 @@ where
     }
 }
 
-async fn not_ready<S, U>(
-    slf: Rc<DispatcherState<S, U>>,
-    pl: PipelineBinding<S, DispatchItem<U>>,
-) where
-    S: Service<DispatchItem<U>, Response = Option<Response<U>>> + 'static,
-    U: Encoder + Decoder + 'static,
-{
-    loop {
-        if !pl.is_shutdown() {
-            if let Err(err) = poll_fn(|cx| pl.poll_ready(cx)).await {
-                slf.error.set(Some(IoDispatcherError::Service(err)));
-                break;
-            }
-            if !pl.is_shutdown() {
-                poll_fn(|cx| pl.poll_not_ready(cx)).await;
-                slf.ready.set(false);
-                slf.waker.wake();
-                continue;
-            }
-        }
-        break;
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use std::{cell::Cell, io, sync::Arc, sync::Mutex};

diff --git a/src/server.rs b/src/server.rs
@@ -1,4 +1,4 @@
-use std::{fmt, io, marker};
+use std::{fmt, io, marker, task::Context};
 
 use ntex_codec::{Decoder, Encoder};
 use ntex_io::{DispatchItem, Filter, Io, IoBoxed};
@@ -234,8 +234,9 @@ where
     }
 
     #[inline]
-    async fn not_ready(&self) {
-        select(self.handlers.0.not_ready(), self.handlers.1.not_ready()).await;
+    fn poll(&self, cx: &mut Context<'_>) -> Result<(), Self::Error> {
+        self.handlers.0.poll(cx)?;
+        self.handlers.1.poll(cx)
     }
 
     #[inline]
@@ -302,8 +303,8 @@ where
     }
 
     #[inline]
-    async fn not_ready(&self) {
-        Service::<IoBoxed>::not_ready(self).await
+    fn poll(&self, cx: &mut Context<'_>) -> Result<(), Self::Error> {
+        Service::<IoBoxed>::poll(self, cx)
     }
 
     #[inline]

diff --git a/src/v3/client/dispatcher.rs b/src/v3/client/dispatcher.rs
@@ -1,8 +1,8 @@
-use std::{cell::RefCell, marker::PhantomData, num::NonZeroU16, rc::Rc};
+use std::{cell::RefCell, marker::PhantomData, num::NonZeroU16, rc::Rc, task::Context};
 
 use ntex_io::DispatchItem;
 use ntex_service::{Pipeline, Service, ServiceCtx};
-use ntex_util::future::{join, select, Either};
+use ntex_util::future::{join, Either};
 use ntex_util::{services::inflight::InFlightService, HashSet};
 
 use crate::error::{HandshakeError, MqttError, ProtocolError};
@@ -38,7 +38,7 @@ pub(crate) struct Dispatcher<T, C: Service<Control<E>>, E> {
 }
 
 struct Inner<C> {
-    control: C,
+    control: Pipeline<C>,
     sink: Rc<MqttShared>,
     inflight: RefCell<HashSet<NonZeroU16>>,
 }
@@ -51,15 +51,19 @@ where
     pub(crate) fn new(sink: Rc<MqttShared>, publish: T, control: C) -> Self {
         Self {
             publish,
-            inner: Rc::new(Inner { sink, control, inflight: RefCell::new(HashSet::default()) }),
+            inner: Rc::new(Inner {
+                sink,
+                control: Pipeline::new(control),
+                inflight: RefCell::new(HashSet::default()),
+            }),
             _t: PhantomData,
         }
     }
 }
 
 impl<T, C, E> Service<DispatchItem<Rc<MqttShared>>> for Dispatcher<T, C, E>
 where
-    T: Service<Publish, Response = Either<(), Publish>, Error = E>,
+    T: Service<Publish, Response = Either<(), Publish>, Error = E> + 'static,
     C: Service<Control<E>, Response = ControlAck, Error = MqttError<E>> + 'static,
     E: 'static,
 {
@@ -68,12 +72,13 @@ where
 
     #[inline]
     async fn ready(&self, ctx: ServiceCtx<'_, Self>) -> Result<(), Self::Error> {
-        let (res1, res2) = join(ctx.ready(&self.publish), ctx.ready(&self.inner.control)).await;
+        let (res1, res2) =
+            join(ctx.ready(&self.publish), ctx.ready(self.inner.control.get_ref())).await;
         if let Err(e) = res1 {
             if res2.is_err() {
                 Err(MqttError::Service(e))
             } else {
-                match ctx.call_nowait(&self.inner.control, Control::error(e)).await {
+                match ctx.call_nowait(self.inner.control.get_ref(), Control::error(e)).await {
                     Ok(_) => {
                         self.inner.sink.close();
                         Ok(())
@@ -86,14 +91,21 @@ where
         }
     }
 
-    #[inline]
-    async fn not_ready(&self) {
-        select(self.publish.not_ready(), self.inner.control.not_ready()).await;
+    fn poll(&self, cx: &mut Context<'_>) -> Result<(), Self::Error> {
+        if let Err(e) = self.publish.poll(cx) {
+            let inner = self.inner.clone();
+            ntex_rt::spawn(async move {
+                if inner.control.call_nowait(Control::error(e.into())).await.is_ok() {
+                    inner.sink.close();
+                }
+            });
+        }
+        self.inner.control.poll(cx)
     }
 
     async fn shutdown(&self) {
         self.inner.sink.close();
-        let _ = Pipeline::new(&self.inner.control).call(Control::closed()).await;
+        let _ = self.inner.control.call(Control::closed()).await;
 
         self.publish.shutdown().await;
         self.inner.control.shutdown().await
@@ -231,7 +243,7 @@ async fn control<'f, T, C, E>(
 where
     C: Service<Control<E>, Response = ControlAck, Error = MqttError<E>>,
 {
-    let packet = match ctx.call(&inner.control, msg).await?.result {
+    let packet = match ctx.call(inner.control.get_ref(), msg).await?.result {
         ControlAckKind::Ping => Some(codec::Packet::PingResponse),
         ControlAckKind::PublishAck(id) => {
             inner.inflight.borrow_mut().remove(&id);

diff --git a/src/v3/dispatcher.rs b/src/v3/dispatcher.rs
@@ -1,10 +1,10 @@
-use std::{cell::RefCell, marker::PhantomData, num::NonZeroU16, rc::Rc};
+use std::{cell::RefCell, marker::PhantomData, num::NonZeroU16, rc::Rc, task::Context};
 
 use ntex_io::DispatchItem;
 use ntex_service::{Pipeline, Service, ServiceCtx, ServiceFactory};
 use ntex_util::services::buffer::{BufferService, BufferServiceError};
 use ntex_util::services::inflight::InFlightService;
-use ntex_util::{future::join, future::select, HashSet};
+use ntex_util::{future::join, HashSet};
 
 use crate::error::{HandshakeError, MqttError, ProtocolError};
 use crate::types::QoS;
@@ -88,7 +88,7 @@ pub(crate) struct Dispatcher<T, C: Service<Control<E>>, E> {
 }
 
 struct Inner<C> {
-    control: C,
+    control: Pipeline<C>,
     sink: Rc<MqttShared>,
     inflight: RefCell<HashSet<NonZeroU16>>,
 }
@@ -110,7 +110,11 @@ where
             publish,
             max_qos,
             handle_qos_after_disconnect,
-            inner: Rc::new(Inner { sink, control, inflight: RefCell::new(HashSet::default()) }),
+            inner: Rc::new(Inner {
+                sink,
+                control: Pipeline::new(control),
+                inflight: RefCell::new(HashSet::default()),
+            }),
             _t: PhantomData,
         }
     }
@@ -119,20 +123,24 @@ where
 impl<T, C, E> Service<DispatchItem<Rc<MqttShared>>> for Dispatcher<T, C, E>
 where
     E: From<T::Error> + 'static,
-    T: Service<Publish, Response = ()>,
+    T: Service<Publish, Response = ()> + 'static,
     C: Service<Control<E>, Response = ControlAck, Error = MqttError<E>> + 'static,
 {
     type Response = Option<codec::Packet>;
     type Error = MqttError<E>;
 
     #[inline]
     async fn ready(&self, ctx: ServiceCtx<'_, Self>) -> Result<(), Self::Error> {
-        let (res1, res2) = join(ctx.ready(&self.publish), ctx.ready(&self.inner.control)).await;
+        let (res1, res2) =
+            join(ctx.ready(&self.publish), ctx.ready(self.inner.control.get_ref())).await;
         if let Err(e) = res1 {
             if res2.is_err() {
                 Err(MqttError::Service(e.into()))
             } else {
-                match ctx.call_nowait(&self.inner.control, Control::error(e.into())).await {
+                match ctx
+                    .call_nowait(self.inner.control.get_ref(), Control::error(e.into()))
+                    .await
+                {
                     Ok(_) => {
                         self.inner.sink.close();
                         Ok(())
@@ -145,14 +153,21 @@ where
         }
     }
 
-    #[inline]
-    async fn not_ready(&self) {
-        select(self.publish.not_ready(), self.inner.control.not_ready()).await;
+    fn poll(&self, cx: &mut Context<'_>) -> Result<(), Self::Error> {
+        if let Err(e) = self.publish.poll(cx) {
+            let inner = self.inner.clone();
+            ntex_rt::spawn(async move {
+                if inner.control.call_nowait(Control::error(e.into())).await.is_ok() {
+                    inner.sink.close();
+                }
+            });
+        }
+        self.inner.control.poll(cx)
     }
 
     async fn shutdown(&self) {
         self.inner.sink.close();
-        let _ = Pipeline::new(&self.inner.control).call(Control::closed()).await;
+        let _ = self.inner.control.call(Control::closed()).await;
 
         self.publish.shutdown().await;
         self.inner.control.shutdown().await;
@@ -387,7 +402,7 @@ where
     let mut error = matches!(pkt, Control::Error(_) | Control::ProtocolError(_));
 
     loop {
-        match ctx.call(&inner.control, pkt).await {
+        match ctx.call(inner.control.get_ref(), pkt).await {
             Ok(item) => {
                 let packet = match item.result {
                     ControlAckKind::Ping => Some(codec::Packet::PingResponse),

diff --git a/src/v3/router.rs b/src/v3/router.rs
@@ -1,4 +1,4 @@
-use std::{future::poll_fn, future::Future, pin::Pin, rc::Rc, task::Poll};
+use std::{rc::Rc, task::Context};
 
 use ntex_router::{IntoPattern, RouterBuilder};
 use ntex_service::boxed::{self, BoxService, BoxServiceFactory};
@@ -117,24 +117,14 @@ impl<Err> Service<Publish> for RouterService<Err> {
     }
 
     #[inline]
-    async fn not_ready(&self) {
-        let mut futs = Vec::with_capacity(self.handlers.len() + 1);
+    fn poll(&self, cx: &mut Context<'_>) -> Result<(), Self::Error> {
         for hnd in &self.handlers {
-            futs.push(Box::pin(hnd.not_ready()));
+            hnd.poll(cx)?;
         }
-        futs.push(Box::pin(self.default.not_ready()));
-
-        poll_fn(|cx| {
-            for hnd in &mut futs {
-                if Pin::new(hnd).poll(cx).is_ready() {
-                    return Poll::Ready(());
-                }
-            }
-            Poll::Pending
-        })
-        .await;
+        self.default.poll(cx)
     }
 
+    #[inline]
     async fn call(
         &self,
         mut req: Publish,