Update Service trait and use unified Counter (#455)

ntex-tls/CHANGES.md

@@ -1,5 +1,9 @@
 # Changes
 
+## [2.3.0] - 2024-11-04
+
+* Use updated Service trait
+
 ## [2.2.0] - 2024-09-25
 
 * Disable default features for rustls

ntex-tls/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ntex-tls"
-version = "2.2.0"
+version = "2.3.0"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "An implementation of SSL streams for ntex backed by OpenSSL"
 keywords = ["network", "framework", "async", "futures"]
@@ -28,8 +28,8 @@ rustls-ring = ["tls_rust", "tls_rust/ring", "tls_rust/std"]
 [dependencies]
 ntex-bytes = "0.1"
 ntex-io = "2.3"
-ntex-util = "2"
-ntex-service = "3"
+ntex-util = "2.5"
+ntex-service = "3.3"
 ntex-net = "2"
 
 log = "0.4"

ntex-tls/src/counter.rs

@@ -1,84 +0,0 @@
-#![allow(dead_code)]
-use std::{cell::Cell, future::poll_fn, rc::Rc, task, task::Poll};
-
-use ntex_util::task::LocalWaker;
-
-#[derive(Debug, Clone)]
-/// Simple counter with ability to notify task on reaching specific number
-///
-/// Counter could be cloned, total count is shared across all clones.
-pub(super) struct Counter(Rc<CounterInner>);
-
-#[derive(Debug)]
-struct CounterInner {
-    count: Cell<usize>,
-    capacity: usize,
-    task: LocalWaker,
-}
-
-impl Counter {
-    /// Create `Counter` instance and set max value.
-    pub(super) fn new(capacity: usize) -> Self {
-        Counter(Rc::new(CounterInner {
-            capacity,
-            count: Cell::new(0),
-            task: LocalWaker::new(),
-        }))
-    }
-
-    /// Get counter guard.
-    pub(super) fn get(&self) -> CounterGuard {
-        CounterGuard::new(self.0.clone())
-    }
-
-    /// Check if counter is not at capacity. If counter at capacity
-    /// it registers notification for current task.
-    pub(super) async fn available(&self) {
-        poll_fn(|cx| {
-            if self.0.available(cx) {
-                Poll::Ready(())
-            } else {
-                Poll::Pending
-            }
-        })
-        .await
-    }
-}
-
-pub(super) struct CounterGuard(Rc<CounterInner>);
-
-impl CounterGuard {
-    fn new(inner: Rc<CounterInner>) -> Self {
-        inner.inc();
-        CounterGuard(inner)
-    }
-}
-
-impl Drop for CounterGuard {
-    fn drop(&mut self) {
-        self.0.dec();
-    }
-}
-
-impl CounterInner {
-    fn inc(&self) {
-        self.count.set(self.count.get() + 1);
-    }
-
-    fn dec(&self) {
-        let num = self.count.get();
-        self.count.set(num - 1);
-        if num == self.capacity {
-            self.task.wake();
-        }
-    }
-
-    fn available(&self, cx: &mut task::Context<'_>) -> bool {
-        if self.count.get() < self.capacity {
-            true
-        } else {
-            self.task.register(cx.waker());
-            false
-        }
-    }
-}

ntex-tls/src/lib.rs

@@ -9,7 +9,7 @@ pub mod openssl;
 #[cfg(feature = "rustls")]
 pub mod rustls;
 
-mod counter;
+use ntex_util::services::Counter;
 
 /// Sets the maximum per-worker concurrent ssl connection establish process.
 ///
@@ -19,12 +19,13 @@ mod counter;
 /// By default max connections is set to a 256.
 pub fn max_concurrent_ssl_accept(num: usize) {
     MAX_SSL_ACCEPT.store(num, Ordering::Relaxed);
+    MAX_SSL_ACCEPT_COUNTER.with(|counts| counts.set_capacity(num));
 }
 
 static MAX_SSL_ACCEPT: AtomicUsize = AtomicUsize::new(256);
 
 thread_local! {
-    static MAX_SSL_ACCEPT_COUNTER: counter::Counter = counter::Counter::new(MAX_SSL_ACCEPT.load(Ordering::Relaxed));
+    static MAX_SSL_ACCEPT_COUNTER: Counter = Counter::new(MAX_SSL_ACCEPT.load(Ordering::Relaxed));
 }
 
 /// A TLS PSK identity.

ntex-tls/src/openssl/accept.rs

@@ -2,13 +2,10 @@ use std::{cell::RefCell, error::Error, fmt, io};
 
 use ntex_io::{Filter, Io, Layer};
 use ntex_service::{Service, ServiceCtx, ServiceFactory};
-use ntex_util::time::{self, Millis};
+use ntex_util::{services::Counter, time, time::Millis};
 use tls_openssl::ssl;
 
-use crate::counter::Counter;
-use crate::MAX_SSL_ACCEPT_COUNTER;
-
-use super::SslFilter;
+use crate::{openssl::SslFilter, MAX_SSL_ACCEPT_COUNTER};
 
 /// Support `TLS` server connections via openssl package
 ///
@@ -98,15 +95,25 @@ impl<F: Filter> Service<Io<F>> for SslAcceptorService {
     type Error = Box<dyn Error>;
 
     async fn ready(&self, _: ServiceCtx<'_, Self>) -> Result<(), Self::Error> {
-        self.conns.available().await;
+        if !self.conns.is_available() {
+            self.conns.available().await
+        }
         Ok(())
     }
 
+    #[inline]
+    async fn not_ready(&self) {
+        if self.conns.is_available() {
+            self.conns.unavailable().await
+        }
+    }
+
     async fn call(
         &self,
         io: Io<F>,
         _: ServiceCtx<'_, Self>,
     ) -> Result<Self::Response, Self::Error> {
+        let _guard = self.conns.get();
         let timeout = self.timeout;
         let ctx_result = ssl::Ssl::new(self.acceptor.context());
 

ntex-tls/src/rustls/accept.rs

@@ -4,10 +4,9 @@ use tls_rust::ServerConfig;
 
 use ntex_io::{Filter, Io, Layer};
 use ntex_service::{Service, ServiceCtx, ServiceFactory};
-use ntex_util::time::Millis;
+use ntex_util::{services::Counter, time::Millis};
 
-use super::TlsServerFilter;
-use crate::{counter::Counter, MAX_SSL_ACCEPT_COUNTER};
+use crate::{rustls::TlsServerFilter, MAX_SSL_ACCEPT_COUNTER};
 
 #[derive(Debug)]
 /// Support `SSL` connections via rustls package
@@ -81,10 +80,19 @@ impl<F: Filter> Service<Io<F>> for TlsAcceptorService {
     type Error = io::Error;
 
     async fn ready(&self, _: ServiceCtx<'_, Self>) -> Result<(), Self::Error> {
-        self.conns.available().await;
+        if !self.conns.is_available() {
+            self.conns.available().await
+        }
         Ok(())
     }
 
+    #[inline]
+    async fn not_ready(&self) {
+        if self.conns.is_available() {
+            self.conns.unavailable().await
+        }
+    }
+
     async fn call(
         &self,
         io: Io<F>,