Move util services to ntex-util (#89)

* move util services to ntex-util

* update versions

ntex-io/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ntex-io"
-version = "0.1.0"
+version = "0.1.1"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "Utilities for encoding and decoding frames"
 keywords = ["network", "framework", "async", "futures"]
@@ -19,10 +19,9 @@ path = "src/lib.rs"
 ntex-codec = "0.6.0"
 ntex-bytes = "0.1.8"
 ntex-util = "0.1.6"
-ntex-service = "0.3.0"
+ntex-service = "0.3.1"
 
 bitflags = "1.3"
-fxhash = "0.2.1"
 log = "0.4"
 pin-project-lite = "0.2"
 

ntex-service/CHANGES.md

@@ -1,5 +1,9 @@
 # Changes
 
+## [0.3.1] - 2022-01-03
+
+* Do not depend on ntex-util
+
 ## [0.3.0] - 2021-12-30
 
 * Remove fn_transform

ntex-service/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ntex-service"
-version = "0.3.0"
+version = "0.3.1"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "ntex service"
 keywords = ["network", "framework", "async", "futures"]
@@ -16,8 +16,8 @@ name = "ntex_service"
 path = "src/lib.rs"
 
 [dependencies]
-ntex-util = "0.1.5"
 pin-project-lite = "0.2.6"
 
 [dev-dependencies]
 ntex = "0.5.0"
+ntex-util = "0.1.5"

ntex-service/src/fn_service.rs

@@ -1,7 +1,5 @@
 use std::task::{Context, Poll};
-use std::{cell::Cell, future::Future, marker::PhantomData};
+use std::{cell::Cell, future::ready, future::Future, future::Ready, marker::PhantomData};
-
-use ntex_util::future::Ready;
 
 use crate::{IntoService, IntoServiceFactory, Service, ServiceFactory};
 
@@ -304,18 +302,18 @@ where
 
     type Service = FnService<F, Fut, Req, Res, Err, FShut>;
     type InitError = ();
-    type Future = Ready<Self::Service, Self::InitError>;
+    type Future = Ready<Result<Self::Service, Self::InitError>>;
 
     #[inline]
     fn new_service(&self, _: Cfg) -> Self::Future {
         let f = self.f_shutdown.take();
         self.f_shutdown.set(f.clone());
 
-        Ready::Ok(FnService {
+        ready(Ok(FnService {
             f: self.f.clone(),
             f_shutdown: Cell::new(f),
             _t: PhantomData,
-        })
+        }))
     }
 }
 

ntex-tls/examples/client.rs

@@ -29,6 +29,7 @@ async fn main() -> io::Result<()> {
         .send(Bytes::from_static(b"hello"), &codec::BytesCodec)
         .await
         .map_err(Either::into_inner)?;
+    println!("Send result: {:?}", result);
 
     let resp = io
         .recv(&codec::BytesCodec)

ntex-util/Cargo.toml

@@ -17,6 +17,7 @@ path = "src/lib.rs"
 
 [dependencies]
 ntex-rt = "0.4.1"
+ntex-service = "0.3.1"
 bitflags = "1.3"
 fxhash = "0.2.1"
 log = "0.4"
@@ -28,6 +29,7 @@ pin-project-lite = "0.2.6"
 
 [dev-dependencies]
 ntex = "0.5.4"
-ntex-rt = "0.4.1"
+ntex-bytes = "0.1.8"
 ntex-macros = "0.1.3"
+derive_more = "0.99"
 futures-util = { version = "0.3", default-features = false, features = ["alloc"] }

ntex-util/src/lib.rs

@@ -1,6 +1,7 @@
 //! Utilities for ntex framework
 pub mod channel;
 pub mod future;
+pub mod services;
 pub mod task;
 pub mod time;
 

ntex-util/src/services/buffer.rs

@@ -3,10 +3,9 @@ use std::cell::{Cell, RefCell};
 use std::task::{Context, Poll};
 use std::{collections::VecDeque, future::Future, marker::PhantomData, pin::Pin, rc::Rc};
 
-use crate::channel::oneshot;
+use ntex_service::{IntoService, Service, Transform};
-use crate::service::{IntoService, Service, Transform};
+
-use crate::task::LocalWaker;
+use crate::{channel::oneshot, future::Either, task::LocalWaker};
-use crate::util::Either;
 
 /// Buffer - service factory for service that can buffer incoming request.
 ///
@@ -229,11 +228,11 @@ impl<R, S: Service<R, Error = E>, E> Future for BufferServiceResponse<R, S, E> {
 
 #[cfg(test)]
 mod tests {
+    use ntex_service::{apply, fn_factory, Service, ServiceFactory};
     use std::task::{Context, Poll};
 
     use super::*;
-    use crate::service::{apply, fn_factory, Service, ServiceFactory};
+    use crate::future::{lazy, Ready};
-    use crate::util::{lazy, Ready};
 
     #[derive(Clone)]
     struct TestService(Rc<Inner>);
@@ -265,7 +264,7 @@ mod tests {
         }
     }
 
-    #[crate::rt_test]
+    #[ntex_macros::rt_test2]
     async fn test_transform() {
         let inner = Rc::new(Inner {
             ready: Cell::new(false),
@@ -313,7 +312,7 @@ mod tests {
         assert!(lazy(|cx| srv.poll_shutdown(cx, false)).await.is_ready());
     }
 
-    #[crate::rt_test]
+    #[ntex_macros::rt_test2]
     async fn test_newtransform() {
         let inner = Rc::new(Inner {
             ready: Cell::new(false),

ntex-util/src/services/counter.rs

@@ -1,6 +1,4 @@
-use std::cell::Cell;
+use std::{cell::Cell, rc::Rc, task};
-use std::rc::Rc;
-use std::task;
 
 use crate::task::LocalWaker;
 
@@ -40,10 +38,6 @@ impl Counter {
     pub fn total(&self) -> usize {
         self.0.count.get()
     }
-
-    pub(crate) fn priv_clone(&self) -> Self {
-        Counter(self.0.clone())
-    }
 }
 
 pub struct CounterGuard(Rc<CounterInner>);

ntex-util/src/services/extensions.rs

@@ -3,7 +3,7 @@ use std::{any::Any, any::TypeId, fmt};
 #[derive(Default)]
 /// A type map of request extensions.
 pub struct Extensions {
-    map: crate::util::HashMap<TypeId, Box<dyn Any>>,
+    map: crate::HashMap<TypeId, Box<dyn Any>>,
 }
 
 impl Extensions {

ntex-util/src/services/inflight.rs

@@ -1,8 +1,9 @@
 //! Service that limits number of in-flight async requests.
 use std::{future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
 
+use ntex_service::{IntoService, Service, Transform};
+
 use super::counter::{Counter, CounterGuard};
-use crate::{IntoService, Service, Transform};
 
 /// InFlight - service factory for service that can limit number of in-flight
 /// async requests.
@@ -108,12 +109,11 @@ impl<T: Service<R>, R> Future for InFlightServiceResponse<T, R> {
 
 #[cfg(test)]
 mod tests {
-    use std::task::{Context, Poll};
+    use ntex_service::{apply, fn_factory, Service, ServiceFactory};
-    use std::time::Duration;
+    use std::{task::Context, task::Poll, time::Duration};
 
     use super::*;
-    use crate::service::{apply, fn_factory, Service, ServiceFactory};
+    use crate::future::lazy;
-    use crate::util::lazy;
 
     struct SleepService(Duration);
 
@@ -135,7 +135,7 @@ mod tests {
         }
     }
 
-    #[crate::rt_test]
+    #[ntex_macros::rt_test2]
     async fn test_transform() {
         let wait_time = Duration::from_millis(50);
 
@@ -151,7 +151,7 @@ mod tests {
         assert!(lazy(|cx| srv.poll_shutdown(cx, false)).await.is_ready());
     }
 
-    #[crate::rt_test]
+    #[ntex_macros::rt_test2]
     async fn test_newtransform() {
         let wait_time = Duration::from_millis(50);
 

ntex-util/src/services/keepalive.rs

@@ -1,8 +1,10 @@
 use std::task::{Context, Poll};
 use std::{cell::Cell, convert::Infallible, marker, time::Duration, time::Instant};
 
+use ntex_service::{Service, ServiceFactory};
+
+use crate::future::Ready;
 use crate::time::{now, sleep, Millis, Sleep};
-use crate::{util::Ready, Service, ServiceFactory};
 
 /// KeepAlive service factory
 ///
@@ -118,14 +120,15 @@ where
 
 #[cfg(test)]
 mod tests {
+    use ntex_service::{Service, ServiceFactory};
+
     use super::*;
-    use crate::service::{Service, ServiceFactory};
+    use crate::future::lazy;
-    use crate::util::lazy;
 
     #[derive(Debug, PartialEq)]
     struct TestErr;
 
-    #[crate::rt_test]
+    #[ntex_macros::rt_test2]
     async fn test_ka() {
         let factory = KeepAlive::new(Millis(100), || TestErr);
         let _ = factory.clone();

ntex-util/src/services/mod.rs

@@ -0,0 +1,11 @@
+pub mod buffer;
+pub mod counter;
+mod extensions;
+pub mod inflight;
+pub mod keepalive;
+pub mod sink;
+pub mod stream;
+pub mod timeout;
+pub mod variant;
+
+pub use self::extensions::Extensions;

ntex-util/src/services/sink.rs

@@ -3,8 +3,9 @@ use std::{
 };
 
 use futures_sink::Sink;
+use ntex_service::Service;
 
-use crate::{service::Service, util::Ready};
+use crate::future::Ready;
 
 /// `SinkService` forwards incoming requests to the provided `Sink`
 pub struct SinkService<S, I> {

ntex-util/src/services/stream.rs

@@ -1,8 +1,10 @@
 use std::{fmt, future::Future, pin::Pin, task::Context, task::Poll};
 
+use log::trace;
+use ntex_service::{IntoService, Service};
+
 use crate::channel::mpsc;
-use crate::service::{IntoService, Service};
+use crate::{future::poll_fn, Sink, Stream};
-use crate::{util::poll_fn, Sink, Stream};
 
 pin_project_lite::pin_project! {
     pub struct Dispatcher<Req, R, S, T, U>
@@ -64,7 +66,7 @@ where
 
         if let Some(is_err) = this.shutdown {
             if let Some(mut sink) = this.sink.take() {
-                crate::rt::spawn(async move {
+                crate::spawn(async move {
                     if poll_fn(|cx| Pin::new(&mut sink).poll_flush(cx))
                         .await
                         .is_ok()
@@ -131,7 +133,7 @@ where
                     Poll::Ready(Some(Ok(item))) => {
                         let tx = this.rx.sender();
                         let fut = this.service.call(item);
-                        crate::rt::spawn(async move {
+                        crate::spawn(async move {
                             let res = fut.await;
                             let _ = tx.send(res);
                         });
@@ -163,11 +165,13 @@ where
 mod tests {
     use std::{cell::Cell, rc::Rc};
 
-    use super::*;
+    use ntex::{codec::Encoder, ws};
-    use crate::util::{next, ByteString, BytesMut};
+    use ntex_bytes::{ByteString, BytesMut};
-    use crate::{channel::mpsc, codec::Encoder, time::sleep, time::Millis, ws};
 
-    #[crate::rt_test]
+    use super::*;
+    use crate::{channel::mpsc, future::next, time::sleep, time::Millis};
+
+    #[ntex_macros::rt_test2]
     async fn test_basic() {
         let counter = Rc::new(Cell::new(0));
         let counter2 = counter.clone();
@@ -180,12 +184,12 @@ mod tests {
         let disp = Dispatcher::new(
             decoder,
             encoder,
-            crate::service::fn_service(move |_| {
+            ntex_service::fn_service(move |_| {
                 counter2.set(counter2.get() + 1);
                 async { Ok(Some(ws::Message::Text(ByteString::from_static("test")))) }
             }),
         );
-        crate::rt::spawn(async move {
+        crate::spawn(async move {
             let _ = disp.await;
         });
 

ntex-util/src/services/timeout.rs

@@ -6,9 +6,10 @@ use std::{
     fmt, future::Future, marker, marker::PhantomData, pin::Pin, task::Context, task::Poll,
 };
 
-use crate::service::{IntoService, Service, Transform};
+use ntex_service::{IntoService, Service, Transform};
+
+use crate::future::Either;
 use crate::time::{sleep, Millis, Sleep};
-use crate::util::Either;
 
 /// Applies a timeout to requests.
 ///
@@ -214,13 +215,14 @@ where
 
 #[cfg(test)]
 mod tests {
-    use derive_more::Display;
     use std::task::{Context, Poll};
     use std::time::Duration;
 
+    use derive_more::Display;
+    use ntex_service::{apply, fn_factory, Service, ServiceFactory};
+
     use super::*;
-    use crate::service::{apply, fn_factory, Service, ServiceFactory};
+    use crate::future::lazy;
-    use crate::util::lazy;
 
     #[derive(Clone, Debug, PartialEq)]
     struct SleepService(Duration);
@@ -254,7 +256,7 @@ mod tests {
         }
     }
 
-    #[crate::rt_test]
+    #[ntex_macros::rt_test2]
     async fn test_success() {
         let resolution = Duration::from_millis(100);
         let wait_time = Duration::from_millis(50);
@@ -268,7 +270,7 @@ mod tests {
             .is_pending());
     }
 
-    #[crate::rt_test]
+    #[ntex_macros::rt_test2]
     async fn test_zero() {
         let wait_time = Duration::from_millis(50);
         let resolution = Duration::from_millis(0);
@@ -278,7 +280,7 @@ mod tests {
         assert!(lazy(|cx| timeout.poll_ready(cx)).await.is_ready());
     }
 
-    #[crate::rt_test]
+    #[ntex_macros::rt_test2]
     async fn test_timeout() {
         let resolution = Duration::from_millis(100);
         let wait_time = Duration::from_millis(500);
@@ -287,7 +289,7 @@ mod tests {
         assert_eq!(timeout.call(()).await, Err(TimeoutError::Timeout));
     }
 
-    #[crate::rt_test]
+    #[ntex_macros::rt_test2]
     #[allow(clippy::redundant_clone)]
     async fn test_timeout_newservice() {
         let resolution = Duration::from_millis(100);

ntex-util/src/services/variant.rs

@@ -1,7 +1,7 @@
 //! Contains `Variant` service and related types and functions.
 use std::{future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
 
-use crate::service::{IntoServiceFactory, Service, ServiceFactory};
+use ntex_service::{IntoServiceFactory, Service, ServiceFactory};
 
 /// Construct `Variant` service factory.
 ///
@@ -292,11 +292,11 @@ variant_impl_and!(VariantFactory7, VariantFactory8, V8, V8R, v8, (V2, V3, V4, V5
 
 #[cfg(test)]
 mod tests {
+    use ntex_service::{fn_factory, Service, ServiceFactory};
     use std::task::{Context, Poll};
 
     use super::*;
-    use crate::service::{fn_factory, Service, ServiceFactory};
+    use crate::future::{lazy, Ready};
-    use crate::util::{lazy, Ready};
 
     #[derive(Clone)]
     struct Srv1;
@@ -340,7 +340,7 @@ mod tests {
         }
     }
 
-    #[crate::rt_test]
+    #[ntex_macros::rt_test2]
     async fn test_variant() {
         let factory = variant(fn_factory(|| async { Ok::<_, ()>(Srv1) }))
             .v2(fn_factory(|| async { Ok::<_, ()>(Srv2) }))

ntex/Cargo.toml

@@ -47,20 +47,19 @@ async-std = ["ntex-rt/async-std", "ntex-async-std"]
 [dependencies]
 ntex-codec = "0.6.0"
 ntex-router = "0.5.1"
-ntex-service = "0.3.0"
+ntex-service = "0.3.1"
 ntex-macros = "0.1.3"
 ntex-util = "0.1.6"
 ntex-bytes = "0.1.8"
 ntex-tls = "0.1.0"
-ntex-rt = "0.4.0"
+ntex-rt = "0.4.1"
-ntex-io = "0.1.0"
+ntex-io = "0.1.1"
 ntex-tokio = "0.1.0"
 ntex-async-std = { version = "0.1.0", optional = true }
 
 base64 = "0.13"
 bitflags = "1.3"
 derive_more = "0.99"
-fxhash = "0.2.1"
 futures-core = { version = "0.3", default-features = false, features = ["alloc"] }
 futures-sink = { version = "0.3", default-features = false, features = ["alloc"] }
 log = "0.4"

ntex/src/lib.rs

@@ -36,7 +36,6 @@ pub(crate) use ntex_macros::rt_test2 as rt_test;
 pub mod connect;
 pub mod http;
 pub mod server;
-pub mod util;
 pub mod web;
 pub mod ws;
 
@@ -99,3 +98,8 @@ pub mod tls {
     //! TLS support for ntex ecosystem.
     pub use ntex_tls::*;
 }
+
+pub mod util {
+    pub use ntex_bytes::{Buf, BufMut, ByteString, Bytes, BytesMut, Pool, PoolId, PoolRef};
+    pub use ntex_util::{future::*, ready, services::*, HashMap, HashSet};
+}

ntex/src/server/config.rs

@@ -5,14 +5,14 @@ use std::{
 
 use log::error;
 
-use crate::util::{counter::CounterGuard, HashMap, Ready};
+use crate::util::{HashMap, Ready};
 use crate::{io::Io, service, util::PoolId};
 
-use super::builder::bind_addr;
 use super::service::{
     BoxedServerService, InternalServiceFactory, ServerMessage, StreamService,
 };
 use super::Token;
+use super::{builder::bind_addr, counter::CounterGuard};
 
 #[derive(Clone)]
 pub struct Config(pub(super) Rc<InnerServiceConfig>);

ntex/src/server/counter.rs

@@ -0,0 +1,85 @@
+use std::{cell::Cell, rc::Rc, task};
+
+use crate::task::LocalWaker;
+
+/// 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>);
+
+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) fn available(&self, cx: &mut task::Context<'_>) -> bool {
+        self.0.available(cx)
+    }
+
+    /// Get total number of acquired counts
+    pub(super) fn total(&self) -> usize {
+        self.0.count.get()
+    }
+
+    pub(super) fn priv_clone(&self) -> Self {
+        Counter(self.0.clone())
+    }
+}
+
+pub(super) struct CounterGuard(Rc<CounterInner>);
+
+impl CounterGuard {
+    fn new(inner: Rc<CounterInner>) -> Self {
+        inner.inc();
+        CounterGuard(inner)
+    }
+}
+
+impl Unpin for CounterGuard {}
+
+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/src/server/mod.rs

@@ -7,6 +7,7 @@ use async_oneshot as oneshot;
 mod accept;
 mod builder;
 mod config;
+mod counter;
 mod service;
 mod socket;
 mod test;

ntex/src/server/service.rs

@@ -5,10 +5,10 @@ use log::error;
 
 use crate::io::Io;
 use crate::service::{Service, ServiceFactory};
-use crate::util::{counter::CounterGuard, Pool, PoolId, Ready};
+use crate::util::{Pool, PoolId, Ready};
 use crate::{rt::spawn, time::Millis};
 
-use super::{socket::Stream, Config, Token};
+use super::{counter::CounterGuard, socket::Stream, Config, Token};
 
 /// Server message
 pub(super) enum ServerMessage {

ntex/src/server/worker.rs

@@ -7,12 +7,11 @@ use futures_core::Stream as FutStream;
 
 use crate::rt::{spawn, Arbiter};
 use crate::time::{sleep, Millis, Sleep};
-use crate::util::{counter::Counter, join_all};
+use crate::util::join_all;
 
 use super::accept::{AcceptNotify, Command};
 use super::service::{BoxedServerService, InternalServiceFactory, ServerMessage};
-use super::socket::Stream;
+use super::{counter::Counter, socket::Stream, Token};
-use super::Token;
 
 #[derive(Debug)]
 pub(super) struct WorkerCommand(Connection);

ntex/src/util/mod.rs

@@ -1,17 +0,0 @@
-pub mod buffer;
-pub mod counter;
-mod extensions;
-pub mod inflight;
-pub mod keepalive;
-pub mod sink;
-pub mod stream;
-pub mod timeout;
-pub mod variant;
-
-pub use self::extensions::Extensions;
-
-pub use ntex_bytes::{Buf, BufMut, ByteString, Bytes, BytesMut, Pool, PoolId, PoolRef};
-pub use ntex_util::{future::*, ready};
-
-pub type HashMap<K, V> = std::collections::HashMap<K, V, fxhash::FxBuildHasher>;
-pub type HashSet<V> = std::collections::HashSet<V, fxhash::FxBuildHasher>;