2025-04-05 13:57:39 +03:00
160 changed files with 2754 additions and 4878 deletions
--- a/.github/workflows/checks.yml
+++ b/.github/workflows/checks.yml
@ -3,17 +3,6 @@ name: Checks
 on: [push, pull_request]

 jobs:
-  check:
-    name: Check
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions-rust-lang/setup-rust-toolchain@v1
-        with:
-          toolchain: stable
-      - run:
-          cargo check --tests --all --no-default-features --features="ntex/compio,ntex/cookie,ntex/url,ntex/compress,ntex/openssl,ntex/rustls,ntex/ws"
-
  clippy:
    name: Clippy
    runs-on: ubuntu-latest
@ -24,7 +13,7 @@ jobs:
          toolchain: stable
          components: clippy
      - run:
-          cargo clippy --tests --all --no-default-features --features="ntex/compio,ntex/cookie,ntex/url,ntex/compress,ntex/openssl,ntex/rustls,ntex/ws"
+          cargo test --all --no-default-features --features="ntex/compio,ntex/cookie,ntex/url,ntex/compress,ntex/openssl,ntex/rustls,ntex/ws,ntex/brotli"

  fmt:
    name: Rustfmt
--- a/.github/workflows/cov.yml
+++ b/.github/workflows/cov.yml
@ -8,6 +8,11 @@ jobs:
    env:
      CARGO_TERM_COLOR: always
    steps:
+      - name: Free Disk Space
+        uses: jlumbroso/free-disk-space@main
+        with:
+          tool-cache: true
+
      - uses: actions/checkout@v4
      - name: Install Rust
        run: rustup update nightly
@ -21,20 +26,18 @@ jobs:
      - name: Clean coverage results
        run: cargo llvm-cov clean --workspace

-      - name: Code coverage (neon)
-        run: cargo llvm-cov --no-report --all --no-default-features --features="ntex/neon,ntex/cookie,ntex/url,ntex/compress,ntex/openssl,ntex/rustls,ntex/ws"
-
-      - name: Code coverage (neon-uring)
-        run: cargo llvm-cov --no-report --all --no-default-features --features="ntex/neon-uring,ntex/cookie,ntex/url,ntex/compress,ntex/openssl,ntex/rustls,ntex/ws"
+      - name: Code coverage (glommio)
+        continue-on-error: true
+        run: cargo llvm-cov --no-report --all --no-default-features --features="ntex/glommio,ntex/cookie,ntex/url,ntex/compress,ntex/openssl,ntex/rustls,ntex/ws,ntex/brotli" -- --skip test_unhandled_data

      - name: Code coverage (tokio)
-        run: cargo llvm-cov --no-report --all --no-default-features --features="ntex/tokio,ntex/cookie,ntex/url,ntex/compress,ntex/openssl,ntex/rustls,ntex/ws"
+        run: cargo llvm-cov --no-report --all --no-default-features --features="ntex/tokio,ntex/cookie,ntex/url,ntex/compress,ntex/openssl,ntex/rustls,ntex/ws,ntex/brotli"

      - name: Code coverage (compio)
-        run: cargo llvm-cov --no-report --all --no-default-features --features="ntex/compio,ntex/cookie,ntex/url,ntex/compress,ntex/openssl,ntex/rustls,ntex/ws"
+        run: cargo llvm-cov --no-report --all --no-default-features --features="ntex/compio,ntex/cookie,ntex/url,ntex/compress,ntex/openssl,ntex/rustls,ntex/ws,ntex/brotli"

      - name: Generate coverage report
-        run: cargo llvm-cov report --lcov --output-path lcov.info --ignore-filename-regex="ntex-compio|ntex-tokio"
+        run: cargo llvm-cov report --lcov --output-path lcov.info --ignore-filename-regex="ntex-compio|ntex-tokio|ntex-glommio|ntex-async-std"

      - name: Upload coverage to Codecov
        uses: codecov/codecov-action@v4
--- a/.github/workflows/linux.yml
+++ b/.github/workflows/linux.yml
@ -16,6 +16,11 @@ jobs:
    runs-on: ubuntu-latest

    steps:
+      - name: Free Disk Space
+        uses: jlumbroso/free-disk-space@main
+        with:
+          tool-cache: true
+
      - uses: actions/checkout@v4

      - name: Install ${{ matrix.version }}
@ -39,25 +44,21 @@ jobs:
          path: ~/.cargo/git
          key: ${{ matrix.version }}-x86_64-unknown-linux-gnu-cargo-index-trimmed-${{ hashFiles('**/Cargo.lock') }}

-      - name: Run tests (neon)
-        timeout-minutes: 40
-        run: |
-          cargo test --all --no-default-features --features="ntex/neon,ntex/cookie,ntex/url,ntex/compress,ntex/openssl,ntex/rustls,ntex/ws"
-
-      - name: Run tests (neon-uring)
-        timeout-minutes: 40
-        run: |
-          cargo test --all --no-default-features --features="ntex/neon-uring,ntex/cookie,ntex/url,ntex/compress,ntex/openssl,ntex/rustls,ntex/ws"
-
      - name: Run tests (tokio)
        timeout-minutes: 40
        run: |
-          cargo test --all --no-fail-fast --no-default-features --features="ntex/tokio,ntex/cookie,ntex/url,ntex/compress,ntex/openssl,ntex/rustls,ntex/ws"
+          cargo test --all --no-fail-fast --no-default-features --features="ntex/tokio,ntex/cookie,ntex/url,ntex/compress,ntex/openssl,ntex/rustls,ntex/ws,ntex/brotli"

      - name: Run tests (compio)
        timeout-minutes: 40
        run: |
-          cargo test --all --no-default-features --features="ntex/compio,ntex/cookie,ntex/url,ntex/compress,ntex/openssl,ntex/rustls,ntex/ws"
+          cargo test --all --no-default-features --features="ntex/compio,ntex/cookie,ntex/url,ntex/compress,ntex/openssl,ntex/rustls,ntex/ws,ntex/brotli"
+
+      - name: Run tests (async-std)
+        timeout-minutes: 40
+        continue-on-error: true
+        run: |
+          cargo test --all --no-default-features --features="ntex/async-std,ntex/cookie,ntex/url,ntex/compress,ntex/openssl,ntex/rustls,ntex/ws,ntex/brotli"

      - name: Install cargo-cache
        continue-on-error: true
--- a/.github/workflows/osx.yml
+++ b/.github/workflows/osx.yml
@ -37,16 +37,12 @@ jobs:
          path: ~/.cargo/git
          key: ${{ matrix.version }}-aarch64-apple-darwin-cargo-index-trimmed-${{ hashFiles('**/Cargo.lock') }}

-      - name: Run tests (neon)
-        timeout-minutes: 40
-        run: cargo test --all --no-default-features --no-fail-fast --features="ntex/neon,ntex/cookie,ntex/url,ntex/compress,ntex/openssl,ntex/rustls,ntex/ws"
-
      - name: Run tests (tokio)
-        run: cargo test --all --no-default-features --no-fail-fast --features="ntex/tokio,ntex/cookie,ntex/url,ntex/compress,ntex/openssl,ntex/rustls,ntex/ws"
+        run: cargo test --all --no-default-features --no-fail-fast --features="ntex/tokio,ntex/cookie,ntex/url,ntex/compress,ntex/openssl,ntex/rustls,ntex/ws,ntex/brotli"

      - name: Run tests (compio)
        timeout-minutes: 40
-        run: cargo test --all --no-default-features --no-fail-fast --features="ntex/compio,ntex/cookie,ntex/url,ntex/compress,ntex/openssl,ntex/rustls,ntex/ws"
+        run: cargo test --all --no-default-features --no-fail-fast --features="ntex/compio,ntex/cookie,ntex/url,ntex/compress,ntex/openssl,ntex/rustls,ntex/ws,ntex/brotli"

      - name: Install cargo-cache
        continue-on-error: true
--- a/.github/workflows/windows.yml
+++ b/.github/workflows/windows.yml
@ -63,8 +63,8 @@ jobs:

      - name: Run tests (tokio)
        run: |
-          cargo test --all --lib --no-default-features --no-fail-fast --features="ntex/tokio,ntex/cookie,ntex/url,ntex/compress,ntex/openssl,ntex/rustls,ntex/ws" -- --skip test_timer
+          cargo test --all --lib --no-default-features --no-fail-fast --features="ntex/tokio,ntex/cookie,ntex/url,ntex/compress,ntex/openssl,ntex/rustls,ntex/ws,ntex/brotli" -- --skip test_timer

      - name: Run tests (compio)
        run: |
-          cargo test --all --lib --no-default-features --no-fail-fast --features="ntex/compio,ntex/cookie,ntex/url,ntex/compress,ntex/openssl,ntex/rustls,ntex/ws" -- --skip test_timer
+          cargo test --all --lib --no-default-features --no-fail-fast --features="ntex/compio,ntex/cookie,ntex/url,ntex/compress,ntex/openssl,ntex/rustls,ntex/ws,ntex/brotli" -- --skip test_timer
--- a/Cargo.toml
+++ b/Cargo.toml
@ -15,18 +15,12 @@ members = [
  "ntex-macros",
  "ntex-util",

+  "ntex-async-std",
  "ntex-compio",
+  "ntex-glommio",
  "ntex-tokio",
 ]

-[workspace.package]
-authors = ["ntex contributors <team@ntex.rs>"]
-repository = "https://github.com/ntex-rs/ntex"
-documentation = "https://docs.rs/ntex/"
-license = "MIT OR Apache-2.0"
-edition = "2021"
-rust-version = "1.75"
-
 [patch.crates-io]
 ntex = { path = "ntex" }
 ntex-bytes = { path = "ntex-bytes" }
@ -43,28 +37,6 @@ ntex-macros = { path = "ntex-macros" }
 ntex-util = { path = "ntex-util" }

 ntex-compio = { path = "ntex-compio" }
+ntex-glommio = { path = "ntex-glommio" }
 ntex-tokio = { path = "ntex-tokio" }
-
-[workspace.dependencies]
-async-channel = "2"
-async-task = "4.5.0"
-atomic-waker = "1.1"
-core_affinity = "0.8"
-bitflags = "2"
-cfg_aliases = "0.2.1"
-cfg-if = "1.0.0"
-crossbeam-channel = "0.5.8"
-crossbeam-queue = "0.3.8"
-futures-util = "0.3.29"
-fxhash = "0.2"
-libc = "0.2.164"
-log = "0.4"
-io-uring = "0.7.4"
-oneshot = "0.1"
-polling = "3.7.4"
-nohash-hasher = "0.2.0"
-scoped-tls = "1.0.1"
-slab = "0.4.9"
-socket2 = "0.5.6"
-windows-sys = "0.52.0"
-thiserror = "1"
+ntex-async-std = { path = "ntex-async-std" }
--- a/README.md
+++ b/README.md
@ -3,7 +3,7 @@
  <p><strong>Framework for composable network services.</strong> </p>
  <p>

-[![build status](https://github.com/ntex-rs/ntex/actions/workflows/linux.yml/badge.svg?branch=master&event=push)](https://github.com/ntex-rs/ntex/actions/workflows/linux.yml/badge.svg) 
+[![build status](https://github.com/ntex-rs/ntex/workflows/CI%20%28Linux%29/badge.svg?branch=master&event=push)](https://github.com/ntex-rs/ntex/actions?query=workflow%3A"CI+(Linux)") 
 [![crates.io](https://img.shields.io/crates/v/ntex.svg)](https://crates.io/crates/ntex) 
 [![Documentation](https://img.shields.io/docsrs/ntex/latest)](https://docs.rs/ntex) 
 [![Version](https://img.shields.io/badge/rustc-1.75+-lightgray.svg)](https://blog.rust-lang.org/2023/12/28/Rust-1.75.0.html) 
@ -18,18 +18,18 @@

 | Platform         | Build Status |
 | ---------------- | ------------ |
-| Linux            | [![build status](https://github.com/ntex-rs/ntex/actions/workflows/linux.yml/badge.svg?branch=master&event=push)](https://github.com/ntex-rs/ntex/actions/workflows/linux.yml/badge.svg) |
-| macOS            | [![build status](https://github.com/ntex-rs/ntex/actions/workflows/osx.yml/badge.svg?branch=master&event=push)](https://github.com/ntex-rs/ntex/actions/workflows/osx.yml/badge.svg) |
-| Windows          | [![build status](https://github.com/ntex-rs/ntex/actions/workflows/windows.yml/badge.svg?branch=master&event=push)](https://github.com/ntex-rs/ntex/actions/workflows/windows.yml/badge.svg) |
+| Linux            | [![build status](https://github.com/ntex-rs/ntex/workflows/CI%20%28Linux%29/badge.svg?branch=master&event=push)](https://github.com/ntex-rs/ntex/actions?query=workflow%3A"CI+(Linux)") |
+| macOS            | [![build status](https://github.com/ntex-rs/ntex/workflows/CI%20%28OSX%29/badge.svg?branch=master&event=push)](https://github.com/ntex-rs/ntex/actions?query=workflow%3A"CI+(OSX)") |
+| Windows          | [![build status](https://github.com/ntex-rs/ntex/workflows/CI%20%28Windows%29/badge.svg?branch=master&event=push)](https://github.com/ntex-rs/ntex/actions?query=workflow%3A"CI+(Windows)") |

 ## Usage

 ntex supports multiple async runtimes, runtime must be selected as a feature. Available options are `compio`, `tokio`,
-`neon` or `neon-uring`.
+`glommio` or `async-std`.

 ```toml
 [dependencies]
-ntex = { version = "2", features = ["compio"] }
+ntex = { version = "2", features = ["tokio"] }
 ```

 ## Documentation & community resources
--- a/ntex-async-std/CHANGES.md
+++ b/ntex-async-std/CHANGES.md
@ -0,0 +1,45 @@
+# Changes
+
+## [0.4.0] - 2024-01-09
+
+* Release
+
+## [0.4.0-b.0] - 2024-01-07
+
+* Use "async fn" in trait for Service definition
+
+## [0.3.2] - 2023-11-22
+
+* Replace async-oneshot with oneshot
+
+## [0.3.1] - 2023-11-12
+
+* Optimize io read task
+
+## [0.3.0] - 2023-06-22
+
+* Release v0.3.0
+
+## [0.3.0-beta.0] - 2023-06-16
+
+* Migrate to ntex-service 1.2
+
+## [0.2.2] - 2023-01-26
+
+* Update io api usage
+
+## [0.2.0] - 2023-01-04
+
+* Release
+
+## [0.2.0-beta.0] - 2022-12-28
+
+* Migrate to ntex-service 1.0
+
+## [0.1.1] - 2022-01-30
+
+* Update to ntex-io 0.1.7
+
+## [0.1.0] - 2022-01-03
+
+* Initial release
--- a/ntex-async-std/Cargo.toml
+++ b/ntex-async-std/Cargo.toml
@ -0,0 +1,24 @@
+[package]
+name = "ntex-async-std"
+version = "0.5.1"
+authors = ["ntex contributors <team@ntex.rs>"]
+description = "async-std intergration for ntex framework"
+keywords = ["network", "framework", "async", "futures"]
+homepage = "https://ntex.rs"
+repository = "https://github.com/ntex-rs/ntex.git"
+documentation = "https://docs.rs/ntex-rt-async-std/"
+categories = ["network-programming", "asynchronous"]
+license = "MIT OR Apache-2.0"
+edition = "2021"
+
+[lib]
+name = "ntex_async_std"
+path = "src/lib.rs"
+
+[dependencies]
+ntex-bytes = "0.1"
+ntex-io = "2.5"
+ntex-util = "2.0"
+log = "0.4"
+async-std = { version = "1", features = ["unstable"] }
+oneshot = { version = "0.1", default-features = false, features = ["async"] }
--- a/ntex-async-std/LICENSE-APACHE
+++ b/ntex-async-std/LICENSE-APACHE
@ -0,0 +1 @@
+../LICENSE-APACHE
--- a/ntex-async-std/LICENSE-MIT
+++ b/ntex-async-std/LICENSE-MIT
@ -0,0 +1 @@
+../LICENSE-MIT
--- a/ntex-async-std/src/io.rs
+++ b/ntex-async-std/src/io.rs
@ -0,0 +1,220 @@
+use std::{
+    any, cell::RefCell, future::poll_fn, io, pin::Pin, task::ready, task::Context,
+    task::Poll,
+};
+
+use async_std::io::{Read as ARead, Write as AWrite};
+use ntex_bytes::{Buf, BufMut, BytesVec};
+use ntex_io::{types, Handle, IoStream, ReadContext, WriteContext, WriteContextBuf};
+
+use crate::TcpStream;
+
+impl IoStream for TcpStream {
+    fn start(self, read: ReadContext, write: WriteContext) -> Option<Box<dyn Handle>> {
+        let mut rio = Read(RefCell::new(self.clone()));
+        async_std::task::spawn_local(async move {
+            read.handle(&mut rio).await;
+        });
+        let mut wio = Write(RefCell::new(self.clone()));
+        async_std::task::spawn_local(async move {
+            write.handle(&mut wio).await;
+        });
+        Some(Box::new(self))
+    }
+}
+
+impl Handle for TcpStream {
+    fn query(&self, id: any::TypeId) -> Option<Box<dyn any::Any>> {
+        if id == any::TypeId::of::<types::PeerAddr>() {
+            if let Ok(addr) = self.0.peer_addr() {
+                return Some(Box::new(types::PeerAddr(addr)));
+            }
+        }
+        None
+    }
+}
+
+/// Read io task
+struct Read(RefCell<TcpStream>);
+
+impl ntex_io::AsyncRead for Read {
+    async fn read(&mut self, mut buf: BytesVec) -> (BytesVec, io::Result<usize>) {
+        // read data from socket
+        let result = poll_fn(|cx| {
+            let mut io = self.0.borrow_mut();
+            poll_read_buf(Pin::new(&mut io.0), cx, &mut buf)
+        })
+        .await;
+        (buf, result)
+    }
+}
+
+struct Write(RefCell<TcpStream>);
+
+impl ntex_io::AsyncWrite for Write {
+    #[inline]
+    async fn write(&mut self, buf: &mut WriteContextBuf) -> io::Result<()> {
+        poll_fn(|cx| {
+            if let Some(mut b) = buf.take() {
+                let result = flush_io(&mut self.0.borrow_mut().0, &mut b, cx);
+                buf.set(b);
+                result
+            } else {
+                Poll::Ready(Ok(()))
+            }
+        })
+        .await
+    }
+
+    #[inline]
+    async fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    async fn shutdown(&mut self) -> io::Result<()> {
+        self.0.borrow().0.shutdown(std::net::Shutdown::Both)
+    }
+}
+
+/// Flush write buffer to underlying I/O stream.
+pub(super) fn flush_io<T: ARead + AWrite + Unpin>(
+    io: &mut T,
+    buf: &mut BytesVec,
+    cx: &mut Context<'_>,
+) -> Poll<io::Result<()>> {
+    let len = buf.len();
+
+    if len != 0 {
+        // log::trace!("flushing framed transport: {:?}", buf.len());
+
+        let mut written = 0;
+        let result = loop {
+            break match Pin::new(&mut *io).poll_write(cx, &buf[written..]) {
+                Poll::Ready(Ok(n)) => {
+                    if n == 0 {
+                        log::trace!("Disconnected during flush, written {}", written);
+                        Poll::Ready(Err(io::Error::new(
+                            io::ErrorKind::WriteZero,
+                            "failed to write frame to transport",
+                        )))
+                    } else {
+                        written += n;
+                        if written == len {
+                            buf.clear();
+                            Poll::Ready(Ok(()))
+                        } else {
+                            continue;
+                        }
+                    }
+                }
+                Poll::Pending => {
+                    // remove written data
+                    buf.advance(written);
+                    Poll::Pending
+                }
+                Poll::Ready(Err(e)) => {
+                    log::trace!("Error during flush: {}", e);
+                    Poll::Ready(Err(e))
+                }
+            };
+        };
+        // log::trace!("flushed {} bytes", written);
+
+        // flush
+        if written > 0 {
+            match Pin::new(&mut *io).poll_flush(cx) {
+                Poll::Ready(Ok(_)) => result,
+                Poll::Pending => Poll::Pending,
+                Poll::Ready(Err(e)) => {
+                    log::trace!("error during flush: {}", e);
+                    Poll::Ready(Err(e))
+                }
+            }
+        } else {
+            result
+        }
+    } else {
+        Poll::Ready(Ok(()))
+    }
+}
+
+pub fn poll_read_buf<T: ARead>(
+    io: Pin<&mut T>,
+    cx: &mut Context<'_>,
+    buf: &mut BytesVec,
+) -> Poll<io::Result<usize>> {
+    let dst = unsafe { &mut *(buf.chunk_mut() as *mut _ as *mut [u8]) };
+    let n = ready!(io.poll_read(cx, dst))?;
+
+    // Safety: This is guaranteed to be the number of initialized (and read)
+    // bytes due to the invariants provided by Read::poll_read() api
+    unsafe {
+        buf.advance_mut(n);
+    }
+
+    Poll::Ready(Ok(n))
+}
+
+#[cfg(unix)]
+mod unixstream {
+    use super::*;
+    use crate::UnixStream;
+
+    impl IoStream for UnixStream {
+        fn start(self, read: ReadContext, write: WriteContext) -> Option<Box<dyn Handle>> {
+            let mut rio = Read(RefCell::new(self.clone()));
+            async_std::task::spawn_local(async move {
+                read.handle(&mut rio).await;
+            });
+            let mut wio = Write(RefCell::new(self));
+            async_std::task::spawn_local(async move {
+                write.handle(&mut wio).await;
+            });
+            None
+        }
+    }
+
+    /// Read io task
+    struct Read(RefCell<UnixStream>);
+
+    impl ntex_io::AsyncRead for Read {
+        async fn read(&mut self, mut buf: BytesVec) -> (BytesVec, io::Result<usize>) {
+            // read data from socket
+            let result = poll_fn(|cx| {
+                let mut io = self.0.borrow_mut();
+                poll_read_buf(Pin::new(&mut io.0), cx, &mut buf)
+            })
+            .await;
+            (buf, result)
+        }
+    }
+
+    struct Write(RefCell<UnixStream>);
+
+    impl ntex_io::AsyncWrite for Write {
+        #[inline]
+        async fn write(&mut self, buf: &mut WriteContextBuf) -> io::Result<()> {
+            poll_fn(|cx| {
+                if let Some(mut b) = buf.take() {
+                    let result = flush_io(&mut self.0.borrow_mut().0, &mut b, cx);
+                    buf.set(b);
+                    result
+                } else {
+                    Poll::Ready(Ok(()))
+                }
+            })
+            .await
+        }
+
+        #[inline]
+        async fn flush(&mut self) -> io::Result<()> {
+            Ok(())
+        }
+
+        #[inline]
+        async fn shutdown(&mut self) -> io::Result<()> {
+            self.0.borrow().0.shutdown(std::net::Shutdown::Both)
+        }
+    }
+}
--- a/ntex-async-std/src/lib.rs
+++ b/ntex-async-std/src/lib.rs
@ -0,0 +1,64 @@
+use std::{io::Result, net, net::SocketAddr};
+
+use ntex_bytes::PoolRef;
+use ntex_io::Io;
+
+mod io;
+mod signals;
+
+pub use self::signals::{signal, Signal};
+
+#[derive(Clone)]
+struct TcpStream(async_std::net::TcpStream);
+
+#[cfg(unix)]
+#[derive(Clone)]
+struct UnixStream(async_std::os::unix::net::UnixStream);
+
+/// Opens a TCP connection to a remote host.
+pub async fn tcp_connect(addr: SocketAddr) -> Result<Io> {
+    let sock = async_std::net::TcpStream::connect(addr).await?;
+    sock.set_nodelay(true)?;
+    Ok(Io::new(TcpStream(sock)))
+}
+
+/// Opens a TCP connection to a remote host and use specified memory pool.
+pub async fn tcp_connect_in(addr: SocketAddr, pool: PoolRef) -> Result<Io> {
+    let sock = async_std::net::TcpStream::connect(addr).await?;
+    sock.set_nodelay(true)?;
+    Ok(Io::with_memory_pool(TcpStream(sock), pool))
+}
+
+#[cfg(unix)]
+/// Opens a unix stream connection.
+pub async fn unix_connect<P>(addr: P) -> Result<Io>
+where
+    P: AsRef<async_std::path::Path>,
+{
+    let sock = async_std::os::unix::net::UnixStream::connect(addr).await?;
+    Ok(Io::new(UnixStream(sock)))
+}
+
+#[cfg(unix)]
+/// Opens a unix stream connection and specified memory pool.
+pub async fn unix_connect_in<P>(addr: P, pool: PoolRef) -> Result<Io>
+where
+    P: AsRef<async_std::path::Path>,
+{
+    let sock = async_std::os::unix::net::UnixStream::connect(addr).await?;
+    Ok(Io::with_memory_pool(UnixStream(sock), pool))
+}
+
+/// Convert std TcpStream to async-std's TcpStream
+pub fn from_tcp_stream(stream: net::TcpStream) -> Result<Io> {
+    stream.set_nonblocking(true)?;
+    stream.set_nodelay(true)?;
+    Ok(Io::new(TcpStream(async_std::net::TcpStream::from(stream))))
+}
+
+#[cfg(unix)]
+/// Convert std UnixStream to async-std's UnixStream
+pub fn from_unix_stream(stream: std::os::unix::net::UnixStream) -> Result<Io> {
+    stream.set_nonblocking(true)?;
+    Ok(Io::new(UnixStream(From::from(stream))))
+}
--- a/ntex-async-std/src/signals.rs
+++ b/ntex-async-std/src/signals.rs
@ -0,0 +1,50 @@
+use std::{cell::RefCell, future::Future, pin::Pin, rc::Rc, task::Context, task::Poll};
+
+thread_local! {
+    static SRUN: RefCell<bool> = const { RefCell::new(false) };
+    static SHANDLERS: Rc<RefCell<Vec<oneshot::Sender<Signal>>>> = Default::default();
+}
+
+/// Different types of process signals
+#[derive(PartialEq, Eq, Clone, Copy, Debug)]
+pub enum Signal {
+    /// SIGHUP
+    Hup,
+    /// SIGINT
+    Int,
+    /// SIGTERM
+    Term,
+    /// SIGQUIT
+    Quit,
+}
+
+/// Register signal handler.
+///
+/// Signals are handled by oneshots, you have to re-register
+/// after each signal.
+pub fn signal() -> Option<oneshot::Receiver<Signal>> {
+    if !SRUN.with(|v| *v.borrow()) {
+        async_std::task::spawn_local(Signals::new());
+    }
+    SHANDLERS.with(|handlers| {
+        let (tx, rx) = oneshot::channel();
+        handlers.borrow_mut().push(tx);
+        Some(rx)
+    })
+}
+
+struct Signals {}
+
+impl Signals {
+    pub(super) fn new() -> Signals {
+        Self {}
+    }
+}
+
+impl Future for Signals {
+    type Output = ();
+
+    fn poll(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Self::Output> {
+        Poll::Ready(())
+    }
+}
--- a/ntex-bytes/src/bytes.rs
+++ b/ntex-bytes/src/bytes.rs
@ -3779,7 +3779,7 @@ impl<const N: usize> PartialEq<BytesMut> for [u8; N] {
    }
 }

-impl<const N: usize> PartialEq<BytesMut> for &[u8; N] {
+impl<'a, const N: usize> PartialEq<BytesMut> for &'a [u8; N] {
    fn eq(&self, other: &BytesMut) -> bool {
        *other == *self
    }
@ -3878,7 +3878,7 @@ impl<const N: usize> PartialEq<Bytes> for [u8; N] {
    }
 }

-impl<const N: usize> PartialEq<Bytes> for &[u8; N] {
+impl<'a, const N: usize> PartialEq<Bytes> for &'a [u8; N] {
    fn eq(&self, other: &Bytes) -> bool {
        *other == *self
    }
@ -4076,7 +4076,7 @@ impl<const N: usize> PartialEq<BytesVec> for [u8; N] {
    }
 }

-impl<const N: usize> PartialEq<BytesVec> for &[u8; N] {
+impl<'a, const N: usize> PartialEq<BytesVec> for &'a [u8; N] {
    fn eq(&self, other: &BytesVec) -> bool {
        *other == *self
    }
--- a/ntex-bytes/src/hex.rs
+++ b/ntex-bytes/src/hex.rs
@ -3,7 +3,7 @@ use std::fmt::{Formatter, LowerHex, Result, UpperHex};

 struct BytesRef<'a>(&'a [u8]);

-impl LowerHex for BytesRef<'_> {
+impl<'a> LowerHex for BytesRef<'a> {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        for b in self.0 {
            write!(f, "{b:02x}")?;
@ -12,7 +12,7 @@ impl LowerHex for BytesRef<'_> {
    }
 }

-impl UpperHex for BytesRef<'_> {
+impl<'a> UpperHex for BytesRef<'a> {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        for b in self.0 {
            write!(f, "{b:02X}")?;
--- a/ntex-compio/CHANGES.md
+++ b/ntex-compio/CHANGES.md
@ -1,17 +1,5 @@
 # Changes

-## [0.2.4] - 2024-12-01
-
-* Depend on individual compio packages
-
-## [0.2.3] - 2024-11-27
-
-* Disable default features
-
-## [0.2.2] - 2024-11-25
-
-* Update to compio 0.13
-
 ## [0.2.1] - 2024-10-31

 * It's not required to close compio sockets explicitly #444
--- a/ntex-compio/Cargo.toml
+++ b/ntex-compio/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "ntex-compio"
-version = "0.2.4"
+version = "0.2.1"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "compio runtime intergration for ntex framework"
 keywords = ["network", "framework", "async", "futures"]
@ -20,11 +20,5 @@ path = "src/lib.rs"
 ntex-bytes = "0.1"
 ntex-io = "2.5"
 ntex-util = "2"
-ntex-rt = "0.4"
 log = "0.4"
-
-compio-buf = "0.5"
-compio-io = "0.5"
-compio-net = "0.6"
-compio-driver = "0.6"
-compio-runtime = { version = "0.6", features = ["io-uring", "polling", "event"] }
+compio = { version = "0.12.0", features = ["macros", "io", "runtime"] }
--- a/ntex-compio/src/io.rs
+++ b/ntex-compio/src/io.rs
@ -1,15 +1,15 @@
 use std::{any, io};

-use compio_buf::{BufResult, IoBuf, IoBufMut, SetBufInit};
-use compio_io::{AsyncRead, AsyncWrite};
-use compio_net::TcpStream;
+use compio::buf::{BufResult, IoBuf, IoBufMut, SetBufInit};
+use compio::io::{AsyncRead, AsyncWrite};
+use compio::net::TcpStream;
 use ntex_bytes::{Buf, BufMut, BytesVec};
 use ntex_io::{types, Handle, IoStream, ReadContext, WriteContext, WriteContextBuf};

 impl IoStream for crate::TcpStream {
    fn start(self, read: ReadContext, write: WriteContext) -> Option<Box<dyn Handle>> {
        let io = self.0.clone();
-        compio_runtime::spawn(async move { run(io.clone(), &read, write).await }).detach();
+        compio::runtime::spawn(async move { run(io.clone(), &read, write).await }).detach();

        Some(Box::new(HandleWrapper(self.0)))
    }
@ -18,7 +18,7 @@ impl IoStream for crate::TcpStream {
 #[cfg(unix)]
 impl IoStream for crate::UnixStream {
    fn start(self, read: ReadContext, write: WriteContext) -> Option<Box<dyn Handle>> {
-        compio_runtime::spawn(async move { run(self.0.clone(), &read, write).await })
+        compio::runtime::spawn(async move { run(self.0.clone(), &read, write).await })
            .detach();

        None
@ -75,7 +75,7 @@ async fn run<T: AsyncRead + AsyncWrite + Clone + 'static>(
    write: WriteContext,
 ) {
    let mut wr_io = WriteIo(io.clone());
-    let wr_task = compio_runtime::spawn(async move {
+    let wr_task = compio::runtime::spawn(async move {
        write.handle(&mut wr_io).await;
        log::debug!("{} Write task is stopped", write.tag());
    });
--- a/ntex-compio/src/lib.rs
+++ b/ntex-compio/src/lib.rs
@ -6,21 +6,21 @@ use ntex_io::Io;
 mod io;

 /// Tcp stream wrapper for compio TcpStream
-struct TcpStream(compio_net::TcpStream);
+struct TcpStream(compio::net::TcpStream);

 #[cfg(unix)]
 /// Tcp stream wrapper for compio UnixStream
-struct UnixStream(compio_net::UnixStream);
+struct UnixStream(compio::net::UnixStream);

 /// Opens a TCP connection to a remote host.
 pub async fn tcp_connect(addr: SocketAddr) -> Result<Io> {
-    let sock = compio_net::TcpStream::connect(addr).await?;
+    let sock = compio::net::TcpStream::connect(addr).await?;
    Ok(Io::new(TcpStream(sock)))
 }

 /// Opens a TCP connection to a remote host and use specified memory pool.
 pub async fn tcp_connect_in(addr: SocketAddr, pool: PoolRef) -> Result<Io> {
-    let sock = compio_net::TcpStream::connect(addr).await?;
+    let sock = compio::net::TcpStream::connect(addr).await?;
    Ok(Io::with_memory_pool(TcpStream(sock), pool))
 }

@ -30,7 +30,7 @@ pub async fn unix_connect<'a, P>(addr: P) -> Result<Io>
 where
    P: AsRef<std::path::Path> + 'a,
 {
-    let sock = compio_net::UnixStream::connect(addr).await?;
+    let sock = compio::net::UnixStream::connect(addr).await?;
    Ok(Io::new(UnixStream(sock)))
 }

@ -40,20 +40,22 @@ pub async fn unix_connect_in<'a, P>(addr: P, pool: PoolRef) -> Result<Io>
 where
    P: AsRef<std::path::Path> + 'a,
 {
-    let sock = compio_net::UnixStream::connect(addr).await?;
+    let sock = compio::net::UnixStream::connect(addr).await?;
    Ok(Io::with_memory_pool(UnixStream(sock), pool))
 }

 /// Convert std TcpStream to tokio's TcpStream
 pub fn from_tcp_stream(stream: net::TcpStream) -> Result<Io> {
    stream.set_nodelay(true)?;
-    Ok(Io::new(TcpStream(compio_net::TcpStream::from_std(stream)?)))
+    Ok(Io::new(TcpStream(compio::net::TcpStream::from_std(
+        stream,
+    )?)))
 }

 #[cfg(unix)]
 /// Convert std UnixStream to tokio's UnixStream
 pub fn from_unix_stream(stream: std::os::unix::net::UnixStream) -> Result<Io> {
-    Ok(Io::new(UnixStream(compio_net::UnixStream::from_std(
+    Ok(Io::new(UnixStream(compio::net::UnixStream::from_std(
        stream,
    )?)))
 }
--- a/ntex-glommio/CHANGES.md
+++ b/ntex-glommio/CHANGES.md
@ -0,0 +1,57 @@
+# Changes
+
+## [0.5.2] - 2024-09-xx
+
+* Update to glommio v0.9
+
+## [0.4.0] - 2024-01-09
+
+* Release
+
+## [0.4.0-b.0] - 2024-01-07
+
+* Use "async fn" in trait for Service definition
+
+## [0.3.1] - 2023-11-22
+
+* Replace async-oneshot with oneshot
+
+## [0.3.0] - 2023-06-22
+
+* Release v0.3.0
+
+## [0.3.0-beta.0] - 2023-06-16
+
+* Migrate to ntex-service 1.2
+
+## [0.2.4] - 2023-05-30
+
+* Fix borrow mut panic #204
+
+## [0.2.3] - 2023-04-11
+
+* Chore upgrade glommio to 0.8
+
+## [0.2.2] - 2023-01-26
+
+* Update io api usage
+
+## [0.2.0] - 2023-01-04
+
+* Release
+
+## [0.2.0-beta.0] - 2022-12-28
+
+* Migrate to ntex-service 1.0
+
+## [0.1.2] - 2022-02-20
+
+* Upgrade to glommio 0.7
+
+## [0.1.1] - 2022-01-30
+
+* Update to ntex-io 0.1.7
+
+## [0.1.0] - 2022-01-17
+
+* Initial release
--- a/ntex-glommio/Cargo.toml
+++ b/ntex-glommio/Cargo.toml
@ -0,0 +1,27 @@
+[package]
+name = "ntex-glommio"
+version = "0.5.2"
+authors = ["ntex contributors <team@ntex.rs>"]
+description = "glommio intergration for ntex framework"
+keywords = ["network", "framework", "async", "futures"]
+homepage = "https://ntex.rs"
+repository = "https://github.com/ntex-rs/ntex.git"
+documentation = "https://docs.rs/ntex-rt-glommio/"
+categories = ["network-programming", "asynchronous"]
+license = "MIT OR Apache-2.0"
+edition = "2021"
+
+[lib]
+name = "ntex_glommio"
+path = "src/lib.rs"
+
+[dependencies]
+ntex-bytes = "0.1"
+ntex-io = "2.5"
+ntex-util = "2.0"
+futures-lite = "2.2"
+log = "0.4"
+oneshot = { version = "0.1", default-features = false, features = ["async"] }
+
+[target.'cfg(target_os = "linux")'.dependencies]
+glommio = "0.9"
--- a/ntex-glommio/LICENSE-APACHE
+++ b/ntex-glommio/LICENSE-APACHE
@ -0,0 +1 @@
+../LICENSE-APACHE
--- a/ntex-glommio/LICENSE-MIT
+++ b/ntex-glommio/LICENSE-MIT
@ -0,0 +1 @@
+../LICENSE-MIT
--- a/ntex-glommio/src/io.rs
+++ b/ntex-glommio/src/io.rs
@ -0,0 +1,205 @@
+use std::{any, future::poll_fn, io, pin::Pin, task::ready, task::Context, task::Poll};
+
+use futures_lite::io::{AsyncRead, AsyncWrite};
+use ntex_bytes::{Buf, BufMut, BytesVec};
+use ntex_io::{types, Handle, IoStream, ReadContext, WriteContext, WriteContextBuf};
+
+use crate::net_impl::{TcpStream, UnixStream};
+
+impl IoStream for TcpStream {
+    fn start(self, read: ReadContext, write: WriteContext) -> Option<Box<dyn Handle>> {
+        let mut rio = Read(self.clone());
+        glommio::spawn_local(async move { read.handle(&mut rio).await }).detach();
+        let mut wio = Write(self.clone());
+        glommio::spawn_local(async move { write.handle(&mut wio).await }).detach();
+        Some(Box::new(self))
+    }
+}
+
+impl IoStream for UnixStream {
+    fn start(self, read: ReadContext, write: WriteContext) -> Option<Box<dyn Handle>> {
+        let mut rio = UnixRead(self.clone());
+        glommio::spawn_local(async move {
+            read.handle(&mut rio).await;
+        })
+        .detach();
+        let mut wio = UnixWrite(self);
+        glommio::spawn_local(async move { write.handle(&mut wio).await }).detach();
+        None
+    }
+}
+
+impl Handle for TcpStream {
+    fn query(&self, id: any::TypeId) -> Option<Box<dyn any::Any>> {
+        if id == any::TypeId::of::<types::PeerAddr>() {
+            if let Ok(addr) = self.0.borrow().peer_addr() {
+                return Some(Box::new(types::PeerAddr(addr)));
+            }
+        }
+        None
+    }
+}
+
+/// Read io task
+struct Read(TcpStream);
+
+impl ntex_io::AsyncRead for Read {
+    async fn read(&mut self, mut buf: BytesVec) -> (BytesVec, io::Result<usize>) {
+        // read data from socket
+        let result = poll_fn(|cx| {
+            let mut io = self.0 .0.borrow_mut();
+            poll_read_buf(Pin::new(&mut *io), cx, &mut buf)
+        })
+        .await;
+        (buf, result)
+    }
+}
+
+struct Write(TcpStream);
+
+impl ntex_io::AsyncWrite for Write {
+    #[inline]
+    async fn write(&mut self, buf: &mut WriteContextBuf) -> io::Result<()> {
+        poll_fn(|cx| {
+            if let Some(mut b) = buf.take() {
+                let result = flush_io(&mut *self.0 .0.borrow_mut(), &mut b, cx);
+                buf.set(b);
+                result
+            } else {
+                Poll::Ready(Ok(()))
+            }
+        })
+        .await
+    }
+
+    #[inline]
+    async fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    async fn shutdown(&mut self) -> io::Result<()> {
+        poll_fn(|cx| Pin::new(&mut *self.0 .0.borrow_mut()).poll_close(cx)).await
+    }
+}
+
+struct UnixRead(UnixStream);
+
+impl ntex_io::AsyncRead for UnixRead {
+    async fn read(&mut self, mut buf: BytesVec) -> (BytesVec, io::Result<usize>) {
+        // read data from socket
+        let result = poll_fn(|cx| {
+            let mut io = self.0 .0.borrow_mut();
+            poll_read_buf(Pin::new(&mut *io), cx, &mut buf)
+        })
+        .await;
+        (buf, result)
+    }
+}
+
+struct UnixWrite(UnixStream);
+
+impl ntex_io::AsyncWrite for UnixWrite {
+    #[inline]
+    async fn write(&mut self, buf: &mut WriteContextBuf) -> io::Result<()> {
+        poll_fn(|cx| {
+            if let Some(mut b) = buf.take() {
+                let result = flush_io(&mut *self.0 .0.borrow_mut(), &mut b, cx);
+                buf.set(b);
+                result
+            } else {
+                Poll::Ready(Ok(()))
+            }
+        })
+        .await
+    }
+
+    #[inline]
+    async fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    async fn shutdown(&mut self) -> io::Result<()> {
+        poll_fn(|cx| Pin::new(&mut *self.0 .0.borrow_mut()).poll_close(cx)).await
+    }
+}
+
+/// Flush write buffer to underlying I/O stream.
+pub(super) fn flush_io<T: AsyncRead + AsyncWrite + Unpin>(
+    io: &mut T,
+    buf: &mut BytesVec,
+    cx: &mut Context<'_>,
+) -> Poll<io::Result<()>> {
+    let len = buf.len();
+
+    if len != 0 {
+        // log::trace!("flushing framed transport: {:?}", buf.len());
+
+        let mut written = 0;
+        let result = loop {
+            break match Pin::new(&mut *io).poll_write(cx, &buf[written..]) {
+                Poll::Ready(Ok(n)) => {
+                    if n == 0 {
+                        log::trace!("Disconnected during flush, written {}", written);
+                        Poll::Ready(Err(io::Error::new(
+                            io::ErrorKind::WriteZero,
+                            "failed to write frame to transport",
+                        )))
+                    } else {
+                        written += n;
+                        if written == len {
+                            buf.clear();
+                            Poll::Ready(Ok(()))
+                        } else {
+                            continue;
+                        }
+                    }
+                }
+                Poll::Pending => {
+                    // remove written data
+                    buf.advance(written);
+                    Poll::Pending
+                }
+                Poll::Ready(Err(e)) => {
+                    log::trace!("Error during flush: {}", e);
+                    Poll::Ready(Err(e))
+                }
+            };
+        };
+        // log::trace!("flushed {} bytes", written);
+
+        // flush
+        if written > 0 {
+            match Pin::new(&mut *io).poll_flush(cx) {
+                Poll::Ready(Ok(_)) => result,
+                Poll::Pending => Poll::Pending,
+                Poll::Ready(Err(e)) => {
+                    log::trace!("error during flush: {}", e);
+                    Poll::Ready(Err(e))
+                }
+            }
+        } else {
+            result
+        }
+    } else {
+        Poll::Ready(Ok(()))
+    }
+}
+
+pub fn poll_read_buf<T: AsyncRead>(
+    io: Pin<&mut T>,
+    cx: &mut Context<'_>,
+    buf: &mut BytesVec,
+) -> Poll<io::Result<usize>> {
+    let dst = unsafe { &mut *(buf.chunk_mut() as *mut _ as *mut [u8]) };
+    let n = ready!(io.poll_read(cx, dst))?;
+
+    // Safety: This is guaranteed to be the number of initialized (and read)
+    // bytes due to the invariants provided by Read::poll_read() api
+    unsafe {
+        buf.advance_mut(n);
+    }
+
+    Poll::Ready(Ok(n))
+}
--- a/ntex-glommio/src/lib.rs
+++ b/ntex-glommio/src/lib.rs
@ -0,0 +1,90 @@
+#[cfg(target_os = "linux")]
+mod io;
+#[cfg(target_os = "linux")]
+mod signals;
+
+#[cfg(target_os = "linux")]
+pub use self::signals::{signal, Signal};
+
+#[cfg(target_os = "linux")]
+mod net_impl {
+    use std::os::unix::io::{FromRawFd, IntoRawFd};
+    use std::{cell::RefCell, io::Result, net, net::SocketAddr, rc::Rc};
+
+    use ntex_bytes::PoolRef;
+    use ntex_io::Io;
+
+    #[derive(Clone)]
+    pub(crate) struct TcpStream(pub(crate) Rc<RefCell<glommio::net::TcpStream>>);
+
+    impl TcpStream {
+        fn new(io: glommio::net::TcpStream) -> Self {
+            Self(Rc::new(RefCell::new(io)))
+        }
+    }
+
+    #[derive(Clone)]
+    pub(crate) struct UnixStream(pub(crate) Rc<RefCell<glommio::net::UnixStream>>);
+
+    impl UnixStream {
+        fn new(io: glommio::net::UnixStream) -> Self {
+            Self(Rc::new(RefCell::new(io)))
+        }
+    }
+
+    /// Opens a TCP connection to a remote host.
+    pub async fn tcp_connect(addr: SocketAddr) -> Result<Io> {
+        let sock = glommio::net::TcpStream::connect(addr).await?;
+        sock.set_nodelay(true)?;
+        Ok(Io::new(TcpStream::new(sock)))
+    }
+
+    /// Opens a TCP connection to a remote host and use specified memory pool.
+    pub async fn tcp_connect_in(addr: SocketAddr, pool: PoolRef) -> Result<Io> {
+        let sock = glommio::net::TcpStream::connect(addr).await?;
+        sock.set_nodelay(true)?;
+        Ok(Io::with_memory_pool(TcpStream::new(sock), pool))
+    }
+
+    /// Opens a unix stream connection.
+    pub async fn unix_connect<P>(addr: P) -> Result<Io>
+    where
+        P: AsRef<std::path::Path>,
+    {
+        let sock = glommio::net::UnixStream::connect(addr).await?;
+        Ok(Io::new(UnixStream::new(sock)))
+    }
+
+    /// Opens a unix stream connection and specified memory pool.
+    pub async fn unix_connect_in<P>(addr: P, pool: PoolRef) -> Result<Io>
+    where
+        P: AsRef<std::path::Path>,
+    {
+        let sock = glommio::net::UnixStream::connect(addr).await?;
+        Ok(Io::with_memory_pool(UnixStream::new(sock), pool))
+    }
+
+    /// Convert std TcpStream to glommio's TcpStream
+    pub fn from_tcp_stream(stream: net::TcpStream) -> Result<Io> {
+        stream.set_nonblocking(true)?;
+        stream.set_nodelay(true)?;
+        unsafe {
+            Ok(Io::new(TcpStream::new(
+                glommio::net::TcpStream::from_raw_fd(stream.into_raw_fd()),
+            )))
+        }
+    }
+
+    /// Convert std UnixStream to glommio's UnixStream
+    pub fn from_unix_stream(stream: std::os::unix::net::UnixStream) -> Result<Io> {
+        stream.set_nonblocking(true)?;
+        unsafe {
+            Ok(Io::new(UnixStream::new(
+                glommio::net::UnixStream::from_raw_fd(stream.into_raw_fd()),
+            )))
+        }
+    }
+}
+
+#[cfg(target_os = "linux")]
+pub use self::net_impl::*;
--- a/ntex-glommio/src/signals.rs
+++ b/ntex-glommio/src/signals.rs
@ -0,0 +1,50 @@
+use std::{cell::RefCell, future::Future, pin::Pin, rc::Rc, task::Context, task::Poll};
+
+thread_local! {
+    static SRUN: RefCell<bool> = const { RefCell::new(false) };
+    static SHANDLERS: Rc<RefCell<Vec<oneshot::Sender<Signal>>>> = Default::default();
+}
+
+/// Different types of process signals
+#[derive(PartialEq, Clone, Copy, Debug)]
+pub enum Signal {
+    /// SIGHUP
+    Hup,
+    /// SIGINT
+    Int,
+    /// SIGTERM
+    Term,
+    /// SIGQUIT
+    Quit,
+}
+
+/// Register signal handler.
+///
+/// Signals are handled by oneshots, you have to re-register
+/// after each signal.
+pub fn signal() -> Option<oneshot::Receiver<Signal>> {
+    if !SRUN.with(|v| *v.borrow()) {
+        glommio::spawn_local(Signals::new()).detach();
+    }
+    SHANDLERS.with(|handlers| {
+        let (tx, rx) = oneshot::channel();
+        handlers.borrow_mut().push(tx);
+        Some(rx)
+    })
+}
+
+struct Signals {}
+
+impl Signals {
+    pub(super) fn new() -> Signals {
+        Self {}
+    }
+}
+
+impl Future for Signals {
+    type Output = ();
+
+    fn poll(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Self::Output> {
+        Poll::Ready(())
+    }
+}
--- a/ntex-http/CHANGES.md
+++ b/ntex-http/CHANGES.md
@ -1,9 +1,5 @@
 # Changes

-## [0.1.13] - 2024-01-30
-
-* Move body related types from ntex::http
-
 ## [0.1.12] - 2024-01-16

 * Update http dependency
--- a/ntex-http/Cargo.toml
+++ b/ntex-http/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "ntex-http"
-version = "0.1.13"
+version = "0.1.12"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "Http types for ntex framework"
 keywords = ["network", "framework", "async", "futures"]
@ -20,14 +20,9 @@ http = "1"
 log = "0.4"
 fxhash = "0.2.1"
 itoa = "1.0.4"
-ntex-bytes = "0.1"
+ntex-bytes = "0.1.21"
 serde = "1"
-futures-core = { version = "0.3", default-features = false, features = ["alloc"] }

 [dev-dependencies]
 bincode = "1"
 serde_json = "1"
-ntex = "2"
-ntex-util = "2"
-ntex-macros = "0.1.3"
-futures-util = { version = "0.3", default-features = false, features = ["alloc"] }
--- a/ntex-http/src/lib.rs
+++ b/ntex-http/src/lib.rs
@ -1,7 +1,6 @@
 //! Http protocol support.
 #![deny(rust_2018_idioms, unreachable_pub, missing_debug_implementations)]

-pub mod body;
 pub mod error;
 mod map;
 mod serde;
--- a/ntex-http/src/map.rs
+++ b/ntex-http/src/map.rs
@ -354,13 +354,13 @@ impl AsName for HeaderName {
    }
 }

-impl AsName for &HeaderName {
+impl<'a> AsName for &'a HeaderName {
    fn as_name(&self) -> Either<&HeaderName, &str> {
        Either::Left(self)
    }
 }

-impl AsName for &str {
+impl<'a> AsName for &'a str {
    fn as_name(&self) -> Either<&HeaderName, &str> {
        Either::Right(self)
    }
@ -372,7 +372,7 @@ impl AsName for String {
    }
 }

-impl AsName for &String {
+impl<'a> AsName for &'a String {
    fn as_name(&self) -> Either<&HeaderName, &str> {
        Either::Right(self.as_str())
    }
--- a/ntex-http/src/serde.rs
+++ b/ntex-http/src/serde.rs
@ -158,7 +158,7 @@ impl<'de> Deserialize<'de> for HeaderValue {

 struct HeaderValueVisitor;

-impl Visitor<'_> for HeaderValueVisitor {
+impl<'de> Visitor<'de> for HeaderValueVisitor {
    type Value = HeaderValue;

    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
--- a/ntex-http/src/value.rs
+++ b/ntex-http/src/value.rs
@ -641,14 +641,14 @@ impl PartialOrd<HeaderValue> for String {
    }
 }

-impl PartialEq<HeaderValue> for &HeaderValue {
+impl<'a> PartialEq<HeaderValue> for &'a HeaderValue {
    #[inline]
    fn eq(&self, other: &HeaderValue) -> bool {
        **self == *other
    }
 }

-impl PartialOrd<HeaderValue> for &HeaderValue {
+impl<'a> PartialOrd<HeaderValue> for &'a HeaderValue {
    #[inline]
    fn partial_cmp(&self, other: &HeaderValue) -> Option<cmp::Ordering> {
        (**self).partial_cmp(other)
@ -675,14 +675,14 @@ where
    }
 }

-impl PartialEq<HeaderValue> for &str {
+impl<'a> PartialEq<HeaderValue> for &'a str {
    #[inline]
    fn eq(&self, other: &HeaderValue) -> bool {
        *other == *self
    }
 }

-impl PartialOrd<HeaderValue> for &str {
+impl<'a> PartialOrd<HeaderValue> for &'a str {
    #[inline]
    fn partial_cmp(&self, other: &HeaderValue) -> Option<cmp::Ordering> {
        self.as_bytes().partial_cmp(other.as_bytes())
--- a/ntex-io/CHANGES.md
+++ b/ntex-io/CHANGES.md
@ -1,39 +1,5 @@
 # Changes

-## [2.11.1] - 2025-03-20
-
-* Add readiness check support
-
-## [2.11.0] - 2025-03-10
-
-* Add single io context
-
-## [2.10.0] - 2025-02-26
-
-* Impl Filter for Sealed #506
-
-## [2.9.3] - 2025-01-21
-
-* Allow to access io write destination buffer
-
-## [2.9.2] - 2024-12-05
-
-* Better error handling
-
-## [2.9.1] - 2024-12-04
-
-* Check service readiness for every turn
-
-## [2.9.0] - 2024-12-04
-
-* Use updated Service trait
-
-## [2.8.3] - 2024-11-10
-
-* Check service readiness once per decoded item
-
-* Run un-readiness check in separate task
-
 ## [2.8.2] - 2024-11-05

 * Do not rely on not_ready(), always check service readiness
--- a/ntex-io/Cargo.toml
+++ b/ntex-io/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "ntex-io"
-version = "2.11.1"
+version = "2.8.2"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "Utilities for encoding and decoding frames"
 keywords = ["network", "framework", "async", "futures"]
@ -18,8 +18,8 @@ path = "src/lib.rs"
 [dependencies]
 ntex-codec = "0.6"
 ntex-bytes = "0.1"
-ntex-util = "2.8"
-ntex-service = "3.4"
+ntex-util = "2.5"
+ntex-service = "3.3"

 bitflags = "2"
 log = "0.4"
@ -28,3 +28,4 @@ pin-project-lite = "0.2"
 [dev-dependencies]
 ntex = "2"
 rand = "0.8"
+env_logger = "0.11"
--- a/ntex-io/src/buf.rs
+++ b/ntex-io/src/buf.rs
@ -152,27 +152,6 @@ impl Stack {
        }
    }

-    pub(crate) fn with_read_source<F, R>(&self, io: &IoRef, f: F) -> R
-    where
-        F: FnOnce(&mut BytesVec) -> R,
-    {
-        let item = self.get_last_level();
-        let mut rb = item.0.take();
-        if rb.is_none() {
-            rb = Some(io.memory_pool().get_read_buf());
-        }
-
-        let result = f(rb.as_mut().unwrap());
-        if let Some(b) = rb {
-            if b.is_empty() {
-                io.memory_pool().release_read_buf(b);
-            } else {
-                item.0.set(Some(b));
-            }
-        }
-        result
-    }
-
    pub(crate) fn with_read_destination<F, R>(&self, io: &IoRef, f: F) -> R
    where
        F: FnOnce(&mut BytesVec) -> R,
@ -239,12 +218,12 @@ impl Stack {

    pub(crate) fn with_write_destination<F, R>(&self, io: &IoRef, f: F) -> R
    where
-        F: FnOnce(Option<&mut BytesVec>) -> R,
+        F: FnOnce(&mut Option<BytesVec>) -> R,
    {
        let item = self.get_last_level();
        let mut wb = item.1.take();

-        let result = f(wb.as_mut());
+        let result = f(&mut wb);

        // check nested updates
        if item.1.take().is_some() {
@ -321,7 +300,7 @@ pub struct ReadBuf<'a> {
    pub(crate) need_write: Cell<bool>,
 }

-impl ReadBuf<'_> {
+impl<'a> ReadBuf<'a> {
    #[inline]
    /// Get io tag
    pub fn tag(&self) -> &'static str {
@ -465,7 +444,7 @@ pub struct WriteBuf<'a> {
    pub(crate) need_write: Cell<bool>,
 }

-impl WriteBuf<'_> {
+impl<'a> WriteBuf<'a> {
    #[inline]
    /// Get io tag
    pub fn tag(&self) -> &'static str {
--- a/ntex-io/src/dispatcher.rs
+++ b/ntex-io/src/dispatcher.rs
@ -126,11 +126,12 @@ pin_project_lite::pin_project! {
 bitflags::bitflags! {
    #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
    struct Flags: u8  {
-        const READY_ERR     = 0b0000001;
-        const IO_ERR        = 0b0000010;
-        const KA_ENABLED    = 0b0000100;
-        const KA_TIMEOUT    = 0b0001000;
-        const READ_TIMEOUT  = 0b0010000;
+        const READY_ERR     = 0b00001;
+        const IO_ERR        = 0b00010;
+        const KA_ENABLED    = 0b00100;
+        const KA_TIMEOUT    = 0b01000;
+        const READ_TIMEOUT  = 0b10000;
+        const READY        = 0b100000;
    }
 }

@ -159,7 +160,7 @@ where
    codec: U,
    service: PipelineBinding<S, DispatchItem<U>>,
    error: Cell<Option<DispatcherError<S::Error, <U as Encoder>::Error>>>,
-    inflight: Cell<u32>,
+    inflight: Cell<usize>,
 }

 #[derive(Copy, Clone, Debug)]
@ -472,7 +473,10 @@ where
    fn poll_service(&mut self, cx: &mut Context<'_>) -> Poll<PollService<U>> {
        // wait until service becomes ready
        match self.shared.service.poll_ready(cx) {
-            Poll::Ready(Ok(_)) => Poll::Ready(self.check_error()),
+            Poll::Ready(Ok(_)) => {
+                let _ = self.shared.service.poll_not_ready(cx);
+                Poll::Ready(self.check_error())
+            }
            // pause io read task
            Poll::Pending => {
                log::trace!(
@ -860,6 +864,8 @@ mod tests {
                Err("test")
            }

+            async fn not_ready(&self) {}
+
            async fn call(
                &self,
                _: DispatchItem<BytesCodec>,
@ -1244,8 +1250,6 @@ mod tests {
                    sleep(Millis(50)).await;
                    if let DispatchItem::Item(msg) = msg {
                        Ok::<_, ()>(Some(msg.freeze()))
-                    } else if let DispatchItem::Disconnect(_) = msg {
-                        Ok::<_, ()>(None)
                    } else {
                        panic!()
                    }
--- a/ntex-io/src/flags.rs
+++ b/ntex-io/src/flags.rs
@ -25,8 +25,6 @@ bitflags::bitflags! {

        /// write task paused
        const WR_PAUSED           = 0b0000_0100_0000_0000;
-        /// wait for write completion task
-        const WR_TASK_WAIT        = 0b0000_1000_0000_0000;

        /// dispatcher is marked stopped
        const DSP_STOP            = 0b0001_0000_0000_0000;
@ -40,10 +38,6 @@ impl Flags {
        self.intersects(Flags::IO_STOPPED)
    }

-    pub(crate) fn is_task_waiting_for_write(&self) -> bool {
-        self.contains(Flags::WR_TASK_WAIT)
-    }
-
    pub(crate) fn is_waiting_for_write(&self) -> bool {
        self.intersects(Flags::BUF_W_MUST_FLUSH | Flags::BUF_W_BACKPRESSURE)
    }
@ -52,18 +46,10 @@ impl Flags {
        self.remove(Flags::BUF_W_MUST_FLUSH | Flags::BUF_W_BACKPRESSURE);
    }

-    pub(crate) fn task_waiting_for_write_is_done(&mut self) {
-        self.remove(Flags::WR_TASK_WAIT);
-    }
-
    pub(crate) fn is_read_buf_ready(&self) -> bool {
        self.contains(Flags::BUF_R_READY)
    }

-    pub(crate) fn is_waiting_for_read(&self) -> bool {
-        self.contains(Flags::RD_NOTIFY)
-    }
-
    pub(crate) fn cannot_read(self) -> bool {
        self.intersects(Flags::RD_PAUSED | Flags::BUF_R_FULL)
    }
--- a/ntex-io/src/io.rs
+++ b/ntex-io/src/io.rs
@ -10,7 +10,7 @@ use ntex_util::{future::Either, task::LocalWaker, time::Seconds};
 use crate::buf::Stack;
 use crate::filter::{Base, Filter, Layer, NullFilter};
 use crate::flags::Flags;
-use crate::seal::{IoBoxed, Sealed};
+use crate::seal::Sealed;
 use crate::tasks::{ReadContext, WriteContext};
 use crate::timer::TimerHandle;
 use crate::{Decoded, FilterLayer, Handle, IoStatusUpdate, IoStream, RecvError};
@ -80,23 +80,6 @@ impl IoState {
        }
    }

-    /// Get current io error
-    pub(super) fn error(&self) -> Option<io::Error> {
-        if let Some(err) = self.error.take() {
-            self.error
-                .set(Some(io::Error::new(err.kind(), format!("{}", err))));
-            Some(err)
-        } else {
-            None
-        }
-    }
-
-    /// Get current io result
-    pub(super) fn error_or_disconnected(&self) -> io::Error {
-        self.error()
-            .unwrap_or_else(|| io::Error::new(io::ErrorKind::NotConnected, "Disconnected"))
-    }
-
    pub(super) fn io_stopped(&self, err: Option<io::Error>) {
        if err.is_some() {
            self.error.set(err);
@ -274,6 +257,19 @@ impl<F> Io<F> {
    fn io_ref(&self) -> &IoRef {
        unsafe { &*self.0.get() }
    }
+
+    /// Get current io error
+    fn error(&self) -> Option<io::Error> {
+        self.st().error.take()
+    }
+
+    /// Get current io error
+    fn error_or_disconnected(&self) -> io::Error {
+        self.st()
+            .error
+            .take()
+            .unwrap_or_else(|| io::Error::new(io::ErrorKind::Other, "Disconnected"))
+    }
 }

 impl<F: FilterLayer, T: Filter> Io<Layer<F, T>> {
@ -294,12 +290,6 @@ impl<F: Filter> Io<F> {
        Io(UnsafeCell::new(state), marker::PhantomData)
    }

-    #[inline]
-    /// Convert current io stream into boxed version
-    pub fn boxed(self) -> IoBoxed {
-        self.seal().into()
-    }
-
    #[inline]
    /// Map current filter with new one
    pub fn add_filter<U>(self, nf: U) -> Io<Layer<U, F>>
@ -343,7 +333,7 @@ impl<F> Io<F> {
                    "Timeout",
                ))),
                Err(RecvError::Stop) => Err(Either::Right(io::Error::new(
-                    io::ErrorKind::UnexpectedEof,
+                    io::ErrorKind::Other,
                    "Dispatcher stopped",
                ))),
                Err(RecvError::WriteBackpressure) => {
@ -433,11 +423,11 @@ impl<F> Io<F> {
        let mut flags = st.flags.get();

        if flags.is_stopped() {
-            Poll::Ready(Err(st.error_or_disconnected()))
+            Poll::Ready(Err(self.error_or_disconnected()))
        } else {
            st.dispatch_task.register(cx.waker());

-            let ready = flags.is_read_buf_ready();
+            let ready = flags.contains(Flags::BUF_R_READY);
            if flags.cannot_read() {
                flags.cleanup_read_flags();
                st.read_task.wake();
@ -521,7 +511,7 @@ impl<F> Io<F> {
            let st = self.st();
            let flags = st.flags.get();
            if flags.is_stopped() {
-                Err(RecvError::PeerGone(st.error()))
+                Err(RecvError::PeerGone(self.error()))
            } else if flags.contains(Flags::DSP_STOP) {
                st.remove_flags(Flags::DSP_STOP);
                Err(RecvError::Stop)
@ -555,31 +545,27 @@ impl<F> Io<F> {
    /// otherwise wake up when size of write buffer is lower than
    /// buffer max size.
    pub fn poll_flush(&self, cx: &mut Context<'_>, full: bool) -> Poll<io::Result<()>> {
-        let st = self.st();
        let flags = self.flags();

-        let len = st.buffer.write_destination_size();
-        if len > 0 {
-            if full {
-                st.insert_flags(Flags::BUF_W_MUST_FLUSH);
-                st.dispatch_task.register(cx.waker());
-                return if flags.is_stopped() {
-                    Poll::Ready(Err(st.error_or_disconnected()))
-                } else {
-                    Poll::Pending
-                };
-            } else if len >= st.pool.get().write_params_high() << 1 {
-                st.insert_flags(Flags::BUF_W_BACKPRESSURE);
-                st.dispatch_task.register(cx.waker());
-                return if flags.is_stopped() {
-                    Poll::Ready(Err(st.error_or_disconnected()))
-                } else {
-                    Poll::Pending
-                };
+        if flags.is_stopped() {
+            Poll::Ready(Err(self.error_or_disconnected()))
+        } else {
+            let st = self.st();
+            let len = st.buffer.write_destination_size();
+            if len > 0 {
+                if full {
+                    st.insert_flags(Flags::BUF_W_MUST_FLUSH);
+                    st.dispatch_task.register(cx.waker());
+                    return Poll::Pending;
+                } else if len >= st.pool.get().write_params_high() << 1 {
+                    st.insert_flags(Flags::BUF_W_BACKPRESSURE);
+                    st.dispatch_task.register(cx.waker());
+                    return Poll::Pending;
+                }
            }
+            st.remove_flags(Flags::BUF_W_MUST_FLUSH | Flags::BUF_W_BACKPRESSURE);
+            Poll::Ready(Ok(()))
        }
-        st.remove_flags(Flags::BUF_W_MUST_FLUSH | Flags::BUF_W_BACKPRESSURE);
-        Poll::Ready(Ok(()))
    }

    #[inline]
@ -589,7 +575,7 @@ impl<F> Io<F> {
        let flags = st.flags.get();

        if flags.is_stopped() {
-            if let Some(err) = st.error() {
+            if let Some(err) = self.error() {
                Poll::Ready(Err(err))
            } else {
                Poll::Ready(Ok(()))
@ -625,7 +611,7 @@ impl<F> Io<F> {
        let st = self.st();
        let flags = st.flags.get();
        if flags.intersects(Flags::IO_STOPPED | Flags::IO_STOPPING) {
-            Poll::Ready(IoStatusUpdate::PeerGone(st.error()))
+            Poll::Ready(IoStatusUpdate::PeerGone(self.error()))
        } else if flags.contains(Flags::DSP_STOP) {
            st.remove_flags(Flags::DSP_STOP);
            Poll::Ready(IoStatusUpdate::Stop)
--- a/ntex-io/src/ioref.rs
+++ b/ntex-io/src/ioref.rs
@ -191,7 +191,7 @@ impl IoRef {
        F: FnOnce(&mut BytesVec) -> R,
    {
        if self.0.flags.get().contains(Flags::IO_STOPPED) {
-            Err(self.0.error_or_disconnected())
+            Err(io::Error::new(io::ErrorKind::Other, "Disconnected"))
        } else {
            let result = self.0.buffer.with_write_source(self, f);
            self.0.filter().process_write_buf(self, &self.0.buffer, 0)?;
@ -199,16 +199,6 @@ impl IoRef {
        }
    }

-    #[doc(hidden)]
-    #[inline]
-    /// Get mut access to destination write buffer
-    pub fn with_write_dest_buf<F, R>(&self, f: F) -> R
-    where
-        F: FnOnce(Option<&mut BytesVec>) -> R,
-    {
-        self.0.buffer.with_write_destination(self, f)
-    }
-
    #[inline]
    /// Get mut access to source read buffer
    pub fn with_read_buf<F, R>(&self, f: F) -> R
@ -569,10 +559,6 @@ mod tests {

        assert_eq!(in_bytes.get(), BIN.len() * 2);
        assert_eq!(out_bytes.get(), 8);
-        assert_eq!(
-            state.with_write_dest_buf(|b| b.map(|b| b.len()).unwrap_or(0)),
-            0
-        );

        // refs
        assert_eq!(Rc::strong_count(&in_bytes), 3);
--- a/ntex-io/src/lib.rs
+++ b/ntex-io/src/lib.rs
@ -29,7 +29,7 @@ pub use self::filter::{Base, Filter, Layer};
 pub use self::framed::Framed;
 pub use self::io::{Io, IoRef, OnDisconnect};
 pub use self::seal::{IoBoxed, Sealed};
-pub use self::tasks::{IoContext, ReadContext, WriteContext, WriteContextBuf};
+pub use self::tasks::{ReadContext, WriteContext, WriteContextBuf};
 pub use self::timer::TimerHandle;
 pub use self::utils::{seal, Decoded};

@ -53,9 +53,7 @@ pub trait AsyncWrite {
 /// Status for read task
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 pub enum ReadStatus {
-    /// Read task is clear to proceed with read operation
    Ready,
-    /// Terminate read task
    Terminate,
 }

--- a/ntex-io/src/seal.rs
+++ b/ntex-io/src/seal.rs
@ -1,7 +1,6 @@
-use std::{any::Any, any::TypeId, fmt, io, ops, task::Context, task::Poll};
+use std::{fmt, ops};

-use crate::filter::{Filter, FilterReadStatus};
-use crate::{buf::Stack, Io, IoRef, ReadStatus, WriteStatus};
+use crate::{filter::Filter, Io};

 /// Sealed filter type
 pub struct Sealed(pub(crate) Box<dyn Filter>);
@ -12,44 +11,6 @@ impl fmt::Debug for Sealed {
    }
 }

-impl Filter for Sealed {
-    #[inline]
-    fn query(&self, id: TypeId) -> Option<Box<dyn Any>> {
-        self.0.query(id)
-    }
-
-    #[inline]
-    fn process_read_buf(
-        &self,
-        io: &IoRef,
-        stack: &Stack,
-        idx: usize,
-        nbytes: usize,
-    ) -> io::Result<FilterReadStatus> {
-        self.0.process_read_buf(io, stack, idx, nbytes)
-    }
-
-    #[inline]
-    fn process_write_buf(&self, io: &IoRef, stack: &Stack, idx: usize) -> io::Result<()> {
-        self.0.process_write_buf(io, stack, idx)
-    }
-
-    #[inline]
-    fn shutdown(&self, io: &IoRef, stack: &Stack, idx: usize) -> io::Result<Poll<()>> {
-        self.0.shutdown(io, stack, idx)
-    }
-
-    #[inline]
-    fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll<ReadStatus> {
-        self.0.poll_read_ready(cx)
-    }
-
-    #[inline]
-    fn poll_write_ready(&self, cx: &mut Context<'_>) -> Poll<WriteStatus> {
-        self.0.poll_write_ready(cx)
-    }
-}
-
 #[derive(Debug)]
 /// Boxed `Io` object with erased filter type
 pub struct IoBoxed(Io<Sealed>);
@ -64,6 +25,12 @@ impl IoBoxed {
    }
 }

+impl From<Io<Sealed>> for IoBoxed {
+    fn from(io: Io<Sealed>) -> Self {
+        Self(io)
+    }
+}
+
 impl<F: Filter> From<Io<F>> for IoBoxed {
    fn from(io: Io<F>) -> Self {
        Self(io.seal())
@ -78,9 +45,3 @@ impl ops::Deref for IoBoxed {
        &self.0
    }
 }
-
-impl From<IoBoxed> for Io<Sealed> {
-    fn from(value: IoBoxed) -> Self {
-        value.0
-    }
-}
--- a/ntex-io/src/tasks.rs
+++ b/ntex-io/src/tasks.rs
@ -1,6 +1,6 @@
-use std::{cell::Cell, fmt, future::poll_fn, io, task::ready, task::Context, task::Poll};
+use std::{cell::Cell, fmt, future::poll_fn, io, task::Context, task::Poll};

-use ntex_bytes::{Buf, BufMut, BytesVec};
+use ntex_bytes::{BufMut, BytesVec};
 use ntex_util::{future::lazy, future::select, future::Either, time::sleep, time::Sleep};

 use crate::{AsyncRead, AsyncWrite, Flags, IoRef, ReadStatus, WriteStatus};
@ -19,13 +19,6 @@ impl ReadContext {
        Self(io.clone(), Cell::new(None))
    }

-    #[doc(hidden)]
-    #[inline]
-    /// Io tag
-    pub fn context(&self) -> IoContext {
-        IoContext::new(&self.0)
-    }
-
    #[inline]
    /// Io tag
    pub fn tag(&self) -> &'static str {
@ -94,7 +87,7 @@ impl ReadContext {

            // handle incoming data
            let total2 = buf.len();
-            let nbytes = total2.saturating_sub(total);
+            let nbytes = if total2 > total { total2 - total } else { 0 };
            let total = total2;

            if let Some(mut first_buf) = inner.buffer.get_read_source() {
@ -128,7 +121,7 @@ impl ReadContext {
                            );
                            // dest buffer has new data, wake up dispatcher
                            inner.dispatch_task.wake();
-                        } else if inner.flags.get().is_waiting_for_read() {
+                        } else if inner.flags.get().contains(Flags::RD_NOTIFY) {
                            // in case of "notify" we must wake up dispatch task
                            // if we read any data from source
                            inner.dispatch_task.wake();
@ -349,604 +342,3 @@ impl WriteContextBuf {
        }
    }
 }
-
-/// Context for io read task
-pub struct IoContext(IoRef);
-
-impl fmt::Debug for IoContext {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("IoContext").field("io", &self.0).finish()
-    }
-}
-
-impl IoContext {
-    pub(crate) fn new(io: &IoRef) -> Self {
-        Self(io.clone())
-    }
-
-    #[inline]
-    /// Io tag
-    pub fn tag(&self) -> &'static str {
-        self.0.tag()
-    }
-
-    #[doc(hidden)]
-    /// Io flags
-    pub fn flags(&self) -> crate::flags::Flags {
-        self.0.flags()
-    }
-
-    #[inline]
-    /// Check readiness for read operations
-    pub fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll<ReadStatus> {
-        self.shutdown_filters();
-        self.0.filter().poll_read_ready(cx)
-    }
-
-    #[inline]
-    /// Check readiness for write operations
-    pub fn poll_write_ready(&self, cx: &mut Context<'_>) -> Poll<WriteStatus> {
-        self.0.filter().poll_write_ready(cx)
-    }
-
-    #[inline]
-    /// Get io error
-    pub fn stopped(&self, e: Option<io::Error>) {
-        self.0 .0.io_stopped(e);
-    }
-
-    /// Wait when io get closed or preparing for close
-    pub async fn shutdown(&self, flush_buf: bool) {
-        let st = &self.0 .0;
-        let mut timeout = None;
-
-        poll_fn(|cx| {
-            let flags = self.0.flags();
-
-            if flags.intersects(Flags::IO_STOPPING | Flags::IO_STOPPED) {
-                Poll::Ready(())
-            } else {
-                st.write_task.register(cx.waker());
-                if flags.contains(Flags::IO_STOPPING_FILTERS) {
-                    if timeout.is_none() {
-                        timeout = Some(sleep(st.disconnect_timeout.get()));
-                    }
-                    if timeout.as_ref().unwrap().poll_elapsed(cx).is_ready() {
-                        st.dispatch_task.wake();
-                        st.insert_flags(Flags::IO_STOPPING);
-                        return Poll::Ready(());
-                    }
-                }
-                Poll::Pending
-            }
-        })
-        .await;
-
-        if flush_buf && !self.0.flags().contains(Flags::WR_PAUSED) {
-            st.insert_flags(Flags::WR_TASK_WAIT);
-
-            poll_fn(|cx| {
-                let flags = self.0.flags();
-
-                if flags.intersects(Flags::WR_PAUSED | Flags::IO_STOPPED) {
-                    Poll::Ready(())
-                } else {
-                    st.write_task.register(cx.waker());
-
-                    if timeout.is_none() {
-                        timeout = Some(sleep(st.disconnect_timeout.get()));
-                    }
-                    if timeout.as_ref().unwrap().poll_elapsed(cx).is_ready() {
-                        Poll::Ready(())
-                    } else {
-                        Poll::Pending
-                    }
-                }
-            })
-            .await;
-        }
-    }
-
-    /// Get read buffer
-    pub fn get_read_buf(&self) -> Poll<BytesVec> {
-        let inner = &self.0 .0;
-
-        if let Some(waker) = inner.read_task.take() {
-            let mut cx = Context::from_waker(&waker);
-
-            if let Poll::Ready(ReadStatus::Ready) = self.0.filter().poll_read_ready(&mut cx)
-            {
-                let mut buf = if inner.flags.get().is_read_buf_ready() {
-                    // read buffer is still not read by dispatcher
-                    // we cannot touch it
-                    inner.pool.get().get_read_buf()
-                } else {
-                    inner
-                        .buffer
-                        .get_read_source()
-                        .unwrap_or_else(|| inner.pool.get().get_read_buf())
-                };
-
-                // make sure we've got room
-                let (hw, lw) = self.0.memory_pool().read_params().unpack();
-                let remaining = buf.remaining_mut();
-                if remaining < lw {
-                    buf.reserve(hw - remaining);
-                }
-                return Poll::Ready(buf);
-            }
-        }
-
-        Poll::Pending
-    }
-
-    pub fn release_read_buf(&self, buf: BytesVec) {
-        let inner = &self.0 .0;
-        if let Some(mut first_buf) = inner.buffer.get_read_source() {
-            first_buf.extend_from_slice(&buf);
-            inner.buffer.set_read_source(&self.0, first_buf);
-        } else {
-            inner.buffer.set_read_source(&self.0, buf);
-        }
-    }
-
-    /// Set read buffer
-    pub fn set_read_buf(&self, result: io::Result<usize>, buf: BytesVec) -> Poll<()> {
-        let inner = &self.0 .0;
-        let (hw, _) = self.0.memory_pool().read_params().unpack();
-
-        if let Some(mut first_buf) = inner.buffer.get_read_source() {
-            first_buf.extend_from_slice(&buf);
-            inner.buffer.set_read_source(&self.0, first_buf);
-        } else {
-            inner.buffer.set_read_source(&self.0, buf);
-        }
-
-        match result {
-            Ok(0) => {
-                inner.io_stopped(None);
-                Poll::Ready(())
-            }
-            Ok(nbytes) => {
-                let filter = self.0.filter();
-                let res = filter
-                    .process_read_buf(&self.0, &inner.buffer, 0, nbytes)
-                    .and_then(|status| {
-                        if status.nbytes > 0 {
-                            // dest buffer has new data, wake up dispatcher
-                            if inner.buffer.read_destination_size() >= hw {
-                                log::trace!(
-                                    "{}: Io read buffer is too large {}, enable read back-pressure",
-                                    self.0.tag(),
-                                    nbytes
-                                );
-                                inner.insert_flags(Flags::BUF_R_READY | Flags::BUF_R_FULL);
-                            } else {
-                                inner.insert_flags(Flags::BUF_R_READY);
-
-                                if nbytes >= hw {
-                                    // read task is paused because of read back-pressure
-                                    // but there is no new data in top most read buffer
-                                    // so we need to wake up read task to read more data
-                                    // otherwise read task would sleep forever
-                                    inner.read_task.wake();
-                                }
-                            }
-                            log::trace!(
-                                "{}: New {} bytes available, wakeup dispatcher",
-                                self.0.tag(),
-                                nbytes
-                            );
-                            if !inner.dispatch_task.wake_checked() {
-                                log::error!("Dispatcher waker is not registered");
-                            }
-                        } else {
-                            if nbytes >= hw {
-                                // read task is paused because of read back-pressure
-                                // but there is no new data in top most read buffer
-                                // so we need to wake up read task to read more data
-                                // otherwise read task would sleep forever
-                                inner.read_task.wake();
-                            }
-                            if inner.flags.get().is_waiting_for_read() {
-                                // in case of "notify" we must wake up dispatch task
-                                // if we read any data from source
-                                inner.dispatch_task.wake();
-                            }
-                        }
-
-                        // while reading, filter wrote some data
-                        // in that case filters need to process write buffers
-                        // and potentialy wake write task
-                        if status.need_write {
-                            inner.write_task.wake();
-                            filter.process_write_buf(&self.0, &inner.buffer, 0)
-                        } else {
-                            Ok(())
-                        }
-                    });
-
-                if let Err(err) = res {
-                    inner.io_stopped(Some(err));
-                    Poll::Ready(())
-                } else {
-                    self.shutdown_filters();
-                    Poll::Pending
-                }
-            }
-            Err(e) => {
-                inner.io_stopped(Some(e));
-                Poll::Ready(())
-            }
-        }
-    }
-
-    /// Get write buffer
-    pub fn get_write_buf(&self) -> Poll<BytesVec> {
-        let inner = &self.0 .0;
-
-        // check write readiness
-        if let Some(waker) = inner.write_task.take() {
-            let ready = self
-                .0
-                .filter()
-                .poll_write_ready(&mut Context::from_waker(&waker));
-            let buf = if matches!(
-                ready,
-                Poll::Ready(WriteStatus::Ready | WriteStatus::Shutdown)
-            ) {
-                inner.buffer.get_write_destination().and_then(|buf| {
-                    if buf.is_empty() {
-                        None
-                    } else {
-                        Some(buf)
-                    }
-                })
-            } else {
-                None
-            };
-
-            if let Some(buf) = buf {
-                return Poll::Ready(buf);
-            }
-        }
-        Poll::Pending
-    }
-
-    pub fn release_write_buf(&self, mut buf: BytesVec) {
-        let inner = &self.0 .0;
-
-        if let Some(b) = inner.buffer.get_write_destination() {
-            buf.extend_from_slice(&b);
-            self.0.memory_pool().release_write_buf(b);
-        }
-        inner.buffer.set_write_destination(buf);
-
-        // if write buffer is smaller than high watermark value, turn off back-pressure
-        let len = inner.buffer.write_destination_size();
-        let mut flags = inner.flags.get();
-
-        if len == 0 {
-            if flags.is_waiting_for_write() {
-                flags.waiting_for_write_is_done();
-                inner.dispatch_task.wake();
-            }
-            flags.insert(Flags::WR_PAUSED);
-            inner.flags.set(flags);
-        } else if flags.contains(Flags::BUF_W_BACKPRESSURE)
-            && len < inner.pool.get().write_params_high() << 1
-        {
-            flags.remove(Flags::BUF_W_BACKPRESSURE);
-            inner.flags.set(flags);
-            inner.dispatch_task.wake();
-        }
-        inner.flags.set(flags);
-    }
-
-    /// Set write buffer
-    pub fn set_write_buf(&self, result: io::Result<usize>, mut buf: BytesVec) -> Poll<()> {
-        let result = match result {
-            Ok(0) => {
-                log::trace!("{}: Disconnected during flush", self.tag());
-                Err(io::Error::new(
-                    io::ErrorKind::WriteZero,
-                    "failed to write frame to transport",
-                ))
-            }
-            Ok(n) => {
-                if n == buf.len() {
-                    buf.clear();
-                    Ok(0)
-                } else {
-                    buf.advance(n);
-                    Ok(buf.len())
-                }
-            }
-            Err(e) => Err(e),
-        };
-
-        let inner = &self.0 .0;
-
-        // set buffer back
-        let result = match result {
-            Ok(0) => {
-                // log::debug!("{}: WROTE ALL {:?}", self.0.tag(), inner.buffer.write_destination_size());
-                self.0.memory_pool().release_write_buf(buf);
-                Ok(inner.buffer.write_destination_size())
-            }
-            Ok(_) => {
-                if let Some(b) = inner.buffer.get_write_destination() {
-                    buf.extend_from_slice(&b);
-                    self.0.memory_pool().release_write_buf(b);
-                }
-                let l = buf.len();
-                // log::debug!("{}: WROTE SOME {:?}", self.0.tag(), l);
-                inner.buffer.set_write_destination(buf);
-                Ok(l)
-            }
-            Err(e) => Err(e),
-        };
-
-        let mut flags = inner.flags.get();
-        match result {
-            Ok(0) => {
-                // all data has been written
-                flags.insert(Flags::WR_PAUSED);
-
-                if flags.is_task_waiting_for_write() {
-                    flags.task_waiting_for_write_is_done();
-                    inner.write_task.wake();
-                }
-
-                if flags.is_waiting_for_write() {
-                    flags.waiting_for_write_is_done();
-                    inner.dispatch_task.wake();
-                }
-                inner.flags.set(flags);
-                Poll::Ready(())
-            }
-            Ok(len) => {
-                // if write buffer is smaller than high watermark value, turn off back-pressure
-                if flags.contains(Flags::BUF_W_BACKPRESSURE)
-                    && len < inner.pool.get().write_params_high() << 1
-                {
-                    flags.remove(Flags::BUF_W_BACKPRESSURE);
-                    inner.flags.set(flags);
-                    inner.dispatch_task.wake();
-                }
-                Poll::Pending
-            }
-            Err(e) => {
-                inner.io_stopped(Some(e));
-                Poll::Ready(())
-            }
-        }
-    }
-
-    /// Get read buffer
-    pub fn is_read_ready(&self) -> bool {
-        // check read readiness
-        if let Some(waker) = self.0 .0.read_task.take() {
-            let mut cx = Context::from_waker(&waker);
-
-            if let Poll::Ready(ReadStatus::Ready) = self.0.filter().poll_read_ready(&mut cx)
-            {
-                return true;
-            }
-        }
-        false
-    }
-
-    pub fn with_read_buf<F>(&self, f: F) -> Poll<()>
-    where
-        F: FnOnce(&mut BytesVec) -> Poll<io::Result<usize>>,
-    {
-        let inner = &self.0 .0;
-        let (hw, lw) = self.0.memory_pool().read_params().unpack();
-        let result = inner.buffer.with_read_source(&self.0, |buf| {
-            // make sure we've got room
-            let remaining = buf.remaining_mut();
-            if remaining < lw {
-                buf.reserve(hw - remaining);
-            }
-
-            f(buf)
-        });
-
-        // handle buffer changes
-        match result {
-            Poll::Ready(Ok(0)) => {
-                inner.io_stopped(None);
-                Poll::Ready(())
-            }
-            Poll::Ready(Ok(nbytes)) => {
-                let filter = self.0.filter();
-                let _ = filter
-                    .process_read_buf(&self.0, &inner.buffer, 0, nbytes)
-                    .and_then(|status| {
-                        if status.nbytes > 0 {
-                            // dest buffer has new data, wake up dispatcher
-                            if inner.buffer.read_destination_size() >= hw {
-                                log::trace!(
-                                    "{}: Io read buffer is too large {}, enable read back-pressure",
-                                    self.0.tag(),
-                                    nbytes
-                                );
-                                inner.insert_flags(Flags::BUF_R_READY | Flags::BUF_R_FULL);
-                            } else {
-                                inner.insert_flags(Flags::BUF_R_READY);
-
-                                if nbytes >= hw {
-                                    // read task is paused because of read back-pressure
-                                    // but there is no new data in top most read buffer
-                                    // so we need to wake up read task to read more data
-                                    // otherwise read task would sleep forever
-                                    inner.read_task.wake();
-                                }
-                            }
-                            log::trace!(
-                                "{}: New {} bytes available, wakeup dispatcher",
-                                self.0.tag(),
-                                nbytes
-                            );
-                            if !inner.dispatch_task.wake_checked() {
-                                log::error!("Dispatcher waker is not registered");
-                            }
-                        } else {
-                            if nbytes >= hw {
-                                // read task is paused because of read back-pressure
-                                // but there is no new data in top most read buffer
-                                // so we need to wake up read task to read more data
-                                // otherwise read task would sleep forever
-                                inner.read_task.wake();
-                            }
-                            if inner.flags.get().is_waiting_for_read() {
-                                // in case of "notify" we must wake up dispatch task
-                                // if we read any data from source
-                                inner.dispatch_task.wake();
-                            }
-                        }
-
-                        // while reading, filter wrote some data
-                        // in that case filters need to process write buffers
-                        // and potentialy wake write task
-                        if status.need_write {
-                            filter.process_write_buf(&self.0, &inner.buffer, 0)
-                        } else {
-                            Ok(())
-                        }
-                    })
-                    .map_err(|err| {
-                        inner.dispatch_task.wake();
-                        inner.io_stopped(Some(err));
-                        inner.insert_flags(Flags::BUF_R_READY);
-                    });
-                Poll::Pending
-            }
-            Poll::Ready(Err(e)) => {
-                inner.io_stopped(Some(e));
-                Poll::Ready(())
-            }
-            Poll::Pending => {
-                self.shutdown_filters();
-                Poll::Pending
-            }
-        }
-    }
-
-    /// Get write buffer
-    pub fn with_write_buf<F>(&self, f: F) -> Poll<()>
-    where
-        F: FnOnce(&BytesVec) -> Poll<io::Result<usize>>,
-    {
-        let inner = &self.0 .0;
-        let result = inner.buffer.with_write_destination(&self.0, |buf| {
-            let Some(buf) =
-                buf.and_then(|buf| if buf.is_empty() { None } else { Some(buf) })
-            else {
-                return Poll::Ready(Ok(0));
-            };
-
-            match ready!(f(buf)) {
-                Ok(0) => {
-                    log::trace!("{}: Disconnected during flush", self.tag());
-                    Poll::Ready(Err(io::Error::new(
-                        io::ErrorKind::WriteZero,
-                        "failed to write frame to transport",
-                    )))
-                }
-                Ok(n) => {
-                    if n == buf.len() {
-                        buf.clear();
-                        Poll::Ready(Ok(0))
-                    } else {
-                        buf.advance(n);
-                        Poll::Ready(Ok(buf.len()))
-                    }
-                }
-                Err(e) => Poll::Ready(Err(e)),
-            }
-        });
-
-        let mut flags = inner.flags.get();
-
-        let result = match result {
-            Poll::Pending => {
-                flags.remove(Flags::WR_PAUSED);
-                Poll::Pending
-            }
-            Poll::Ready(Ok(0)) => {
-                // all data has been written
-                flags.insert(Flags::WR_PAUSED);
-
-                if flags.is_task_waiting_for_write() {
-                    flags.task_waiting_for_write_is_done();
-                    inner.write_task.wake();
-                }
-
-                if flags.is_waiting_for_write() {
-                    flags.waiting_for_write_is_done();
-                    inner.dispatch_task.wake();
-                }
-                Poll::Ready(())
-            }
-            Poll::Ready(Ok(len)) => {
-                // if write buffer is smaller than high watermark value, turn off back-pressure
-                if flags.contains(Flags::BUF_W_BACKPRESSURE)
-                    && len < inner.pool.get().write_params_high() << 1
-                {
-                    flags.remove(Flags::BUF_W_BACKPRESSURE);
-                    inner.dispatch_task.wake();
-                }
-                Poll::Pending
-            }
-            Poll::Ready(Err(e)) => {
-                self.0 .0.io_stopped(Some(e));
-                Poll::Ready(())
-            }
-        };
-
-        inner.flags.set(flags);
-        result
-    }
-
-    fn shutdown_filters(&self) {
-        let io = &self.0;
-        let st = &self.0 .0;
-        if st.flags.get().contains(Flags::IO_STOPPING_FILTERS) {
-            let flags = st.flags.get();
-
-            if !flags.intersects(Flags::IO_STOPPED | Flags::IO_STOPPING) {
-                let filter = io.filter();
-                match filter.shutdown(io, &st.buffer, 0) {
-                    Ok(Poll::Ready(())) => {
-                        st.dispatch_task.wake();
-                        st.insert_flags(Flags::IO_STOPPING);
-                    }
-                    Ok(Poll::Pending) => {
-                        // check read buffer, if buffer is not consumed it is unlikely
-                        // that filter will properly complete shutdown
-                        if flags.contains(Flags::RD_PAUSED)
-                            || flags.contains(Flags::BUF_R_FULL | Flags::BUF_R_READY)
-                        {
-                            st.dispatch_task.wake();
-                            st.insert_flags(Flags::IO_STOPPING);
-                        }
-                    }
-                    Err(err) => {
-                        st.io_stopped(Some(err));
-                    }
-                }
-                if let Err(err) = filter.process_write_buf(io, &st.buffer, 0) {
-                    st.io_stopped(Some(err));
-                }
-            }
-        }
-    }
-}
-
-impl Clone for IoContext {
-    fn clone(&self) -> Self {
-        Self(self.0.clone())
-    }
-}
--- a/ntex-io/src/utils.rs
+++ b/ntex-io/src/utils.rs
@ -27,7 +27,7 @@ where
    S: ServiceFactory<IoBoxed, C>,
    C: Clone,
 {
-    chain_factory(fn_service(|io: Io<F>| Ready::Ok(io.boxed())))
+    chain_factory(fn_service(|io: Io<F>| Ready::Ok(IoBoxed::from(io))))
        .map_init_err(|_| panic!())
        .and_then(srv)
 }
--- a/ntex-macros/CHANGES.md
+++ b/ntex-macros/CHANGES.md
@ -1,9 +1,5 @@
 # Changes

-## [0.1.4] - 2025-03-14
-
-* Enable env_logger for test macro
-
 ## [0.1.2] - 2021-02-25

 * Export runtime from ntex crate
--- a/ntex-macros/Cargo.toml
+++ b/ntex-macros/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "ntex-macros"
-version = "0.1.4"
+version = "0.1.3"
 description = "ntex proc macros"
 readme = "README.md"
 authors = ["ntex contributors <team@ntex.rs>"]
@ -18,3 +18,4 @@ proc-macro2 = "^1"
 [dev-dependencies]
 ntex = "2"
 futures = "0.3"
+env_logger = "0.11"
--- a/ntex-macros/src/lib.rs
+++ b/ntex-macros/src/lib.rs
@ -262,7 +262,6 @@ pub fn rt_test(_: TokenStream, item: TokenStream) -> TokenStream {
        quote! {
            #(#attrs)*
            fn #name() #ret {
-                ntex::util::enable_test_logging();
                ntex::rt::System::new("test")
                    .block_on(async { #body })
            }
@ -272,7 +271,6 @@ pub fn rt_test(_: TokenStream, item: TokenStream) -> TokenStream {
            #[test]
            #(#attrs)*
            fn #name() #ret {
-                ntex::util::enable_test_logging();
                ntex::rt::System::new("test")
                    .block_on(async { #body })
            }
--- a/ntex-net/CHANGES.md
+++ b/ntex-net/CHANGES.md
@ -1,55 +1,5 @@
 # Changes

-## [2.5.10] - 2025-03-28
-
-* Better closed sockets handling
-
-## [2.5.9] - 2025-03-27
-
-* Handle closed sockets
-
-## [2.5.8] - 2025-03-25
-
-* Update neon runtime
-
-## [2.5.7] - 2025-03-21
-
-* Simplify neon poll impl
-
-## [2.5.6] - 2025-03-20
-
-* Redesign neon poll support
-
-## [2.5.5] - 2025-03-17
-
-* Add check for required io-uring opcodes
-
-* Handle io-uring cancelation
-
-## [2.5.4] - 2025-03-15
-
-* Close FD in various case for poll driver
-
-## [2.5.3] - 2025-03-14
-
-* Fix operation cancelation handling for poll driver
-
-## [2.5.2] - 2025-03-14
-
-* Fix operation cancelation handling for io-uring driver
-
-## [2.5.1] - 2025-03-14
-
-* Fix socket connect for io-uring driver
-
-## [2.5.0] - 2025-03-12
-
-* Add neon runtime support
-
-* Drop glommio support
-
-* Drop async-std support
-
 ## [2.4.0] - 2024-09-25

 * Update to glommio v0.9
--- a/ntex-net/Cargo.toml
+++ b/ntex-net/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "ntex-net"
-version = "2.5.10"
+version = "2.4.0"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "ntexwork utils for ntex framework"
 keywords = ["network", "framework", "async", "futures"]
@ -24,36 +24,28 @@ tokio = ["ntex-rt/tokio", "ntex-tokio"]
 # compio runtime
 compio = ["ntex-rt/compio", "ntex-compio"]

-# neon runtime
-neon = ["ntex-rt/neon", "ntex-neon", "slab", "socket2"]
+# glommio runtime
+glommio = ["ntex-rt/glommio", "ntex-glommio"]

-polling = ["ntex-neon/polling", "dep:polling", "socket2"]
-io-uring = ["ntex-neon/io-uring", "dep:io-uring", "socket2"]
+# async-std runtime
+async-std = ["ntex-rt/async-std", "ntex-async-std"]

 [dependencies]
 ntex-service = "3.3"
 ntex-bytes = "0.1"
 ntex-http = "0.1"
-ntex-io = "2.11.1"
-ntex-rt = "0.4.25"
+ntex-io = "2.8"
+ntex-rt = "0.4.18"
 ntex-util = "2.5"

 ntex-tokio = { version = "0.5.3", optional = true }
-ntex-compio = { version = "0.2.4", optional = true }
-ntex-neon = { version = "0.1.15", optional = true }
+ntex-compio = { version = "0.2.1", optional = true }
+ntex-glommio = { version = "0.5.2", optional = true }
+ntex-async-std = { version = "0.5.1", optional = true }

-bitflags = { workspace = true }
-cfg-if = { workspace = true }
-log = { workspace = true }
-libc = { workspace = true }
-slab = { workspace = true, optional = true }
-socket2 = { workspace = true, optional = true, features = ["all"] }
-thiserror = { workspace = true }
-
-# Linux specific dependencies
-[target.'cfg(target_os = "linux")'.dependencies]
-io-uring = { workspace = true, optional = true }
-polling = { workspace = true, optional = true }
+log = "0.4"
+thiserror = "1"

 [dev-dependencies]
 ntex = "2"
+env_logger = "0.11"
--- a/ntex-net/src/compat.rs
+++ b/ntex-net/src/compat.rs
@ -6,18 +6,63 @@ pub use ntex_tokio::{from_tcp_stream, tcp_connect, tcp_connect_in};
 #[cfg(all(unix, feature = "tokio"))]
 pub use ntex_tokio::{from_unix_stream, unix_connect, unix_connect_in};

-#[cfg(all(feature = "compio", not(feature = "tokio"), not(feature = "neon")))]
+#[cfg(all(
+    feature = "compio",
+    not(feature = "tokio"),
+    not(feature = "async-std"),
+    not(feature = "glommio")
+))]
 pub use ntex_compio::{from_tcp_stream, tcp_connect, tcp_connect_in};

 #[cfg(all(
    unix,
    feature = "compio",
    not(feature = "tokio"),
-    not(feature = "neon")
+    not(feature = "async-std"),
+    not(feature = "glommio")
 ))]
 pub use ntex_compio::{from_unix_stream, unix_connect, unix_connect_in};

-#[cfg(all(not(feature = "tokio"), not(feature = "compio"), not(feature = "neon")))]
+#[cfg(all(
+    feature = "async-std",
+    not(feature = "tokio"),
+    not(feature = "compio"),
+    not(feature = "glommio")
+))]
+pub use ntex_async_std::{from_tcp_stream, tcp_connect, tcp_connect_in};
+
+#[cfg(all(
+    unix,
+    feature = "async-std",
+    not(feature = "tokio"),
+    not(feature = "compio"),
+    not(feature = "glommio")
+))]
+pub use ntex_async_std::{from_unix_stream, unix_connect, unix_connect_in};
+
+#[cfg(all(
+    feature = "glommio",
+    not(feature = "tokio"),
+    not(feature = "compio"),
+    not(feature = "async-std")
+))]
+pub use ntex_glommio::{from_tcp_stream, tcp_connect, tcp_connect_in};
+
+#[cfg(all(
+    unix,
+    feature = "glommio",
+    not(feature = "tokio"),
+    not(feature = "compio"),
+    not(feature = "async-std")
+))]
+pub use ntex_glommio::{from_unix_stream, unix_connect, unix_connect_in};
+
+#[cfg(all(
+    not(feature = "tokio"),
+    not(feature = "compio"),
+    not(feature = "async-std"),
+    not(feature = "glommio")
+))]
 mod no_rt {
    use ntex_io::Io;

@ -82,5 +127,10 @@ mod no_rt {
    }
 }

-#[cfg(all(not(feature = "tokio"), not(feature = "compio"), not(feature = "neon")))]
+#[cfg(all(
+    not(feature = "tokio"),
+    not(feature = "compio"),
+    not(feature = "async-std"),
+    not(feature = "glommio")
+))]
 pub use no_rt::*;
--- a/ntex-net/src/connect/service.rs
+++ b/ntex-net/src/connect/service.rs
@ -197,7 +197,7 @@ impl<T: Address> Future for TcpConnectorResponse<T> {
                    Poll::Ready(Ok(sock)) => {
                        let req = this.req.take().unwrap();
                        log::trace!(
-                            "{}: TCP connector - successfully connected to {:?} - {:?}",
+                            "{}: TCP connector - successfully connected to connecting to {:?} - {:?}",
                            this.tag,
                            req.host(),
                            sock.query::<types::PeerAddr>().get()
--- a/ntex-net/src/helpers.rs
+++ b/ntex-net/src/helpers.rs
@ -1,86 +0,0 @@
-use std::{io, net::SocketAddr, os::fd::FromRawFd, path::Path};
-
-use ntex_neon::syscall;
-use ntex_util::channel::oneshot::channel;
-use socket2::{Protocol, SockAddr, Socket, Type};
-
-pub(crate) fn pool_io_err<T, E>(result: std::result::Result<T, E>) -> io::Result<T> {
-    result.map_err(|_| io::Error::new(io::ErrorKind::Other, "Thread pool panic"))
-}
-
-pub(crate) async fn connect(addr: SocketAddr) -> io::Result<Socket> {
-    let addr = SockAddr::from(addr);
-    let domain = addr.domain().into();
-    connect_inner(addr, domain, Type::STREAM.into(), Protocol::TCP.into()).await
-}
-
-pub(crate) async fn connect_unix(path: impl AsRef<Path>) -> io::Result<Socket> {
-    let addr = SockAddr::unix(path)?;
-    connect_inner(addr, socket2::Domain::UNIX.into(), Type::STREAM.into(), 0).await
-}
-
-async fn connect_inner(
-    addr: SockAddr,
-    domain: i32,
-    socket_type: i32,
-    protocol: i32,
-) -> io::Result<Socket> {
-    #[allow(unused_mut)]
-    let mut ty = socket_type;
-    #[cfg(any(
-        target_os = "android",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "fuchsia",
-        target_os = "hurd",
-        target_os = "illumos",
-        target_os = "linux",
-        target_os = "netbsd",
-        target_os = "openbsd",
-    ))]
-    {
-        ty |= libc::SOCK_CLOEXEC;
-    }
-
-    let fd = ntex_rt::spawn_blocking(move || syscall!(libc::socket(domain, ty, protocol)))
-        .await
-        .map_err(|e| io::Error::new(io::ErrorKind::Other, e))
-        .and_then(pool_io_err)?;
-
-    let (sender, rx) = channel();
-
-    crate::rt_impl::connect::ConnectOps::current().connect(fd, addr, sender)?;
-
-    rx.await
-        .map_err(|_| io::Error::new(io::ErrorKind::Other, "IO Driver is gone"))
-        .and_then(|item| item)?;
-
-    Ok(unsafe { Socket::from_raw_fd(fd) })
-}
-
-pub(crate) fn prep_socket(sock: Socket) -> io::Result<Socket> {
-    #[cfg(not(any(
-        target_os = "android",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "fuchsia",
-        target_os = "hurd",
-        target_os = "illumos",
-        target_os = "linux",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "espidf",
-        target_os = "vita",
-    )))]
-    sock.set_cloexec(true)?;
-    #[cfg(any(
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "tvos",
-        target_os = "watchos",
-    ))]
-    sock.set_nosigpipe(true)?;
-    sock.set_nonblocking(true)?;
-
-    Ok(sock)
-}
--- a/ntex-net/src/lib.rs
+++ b/ntex-net/src/lib.rs
@ -1,6 +1,5 @@
 //! Utility for async runtime abstraction
 #![deny(rust_2018_idioms, unreachable_pub, missing_debug_implementations)]
-#![allow(unused_variables, dead_code)]

 mod compat;
 pub mod connect;
@ -8,25 +7,4 @@ pub mod connect;
 pub use ntex_io::Io;
 pub use ntex_rt::{spawn, spawn_blocking};

-cfg_if::cfg_if! {
-    if #[cfg(all(feature = "neon", target_os = "linux", feature = "io-uring"))] {
-        #[path = "rt_uring/mod.rs"]
-        mod rt_impl;
-        pub use self::rt_impl::{
-            from_tcp_stream, from_unix_stream, tcp_connect, tcp_connect_in, unix_connect,
-            unix_connect_in,
-        };
-    } else if #[cfg(all(unix, feature = "neon"))] {
-        #[path = "rt_polling/mod.rs"]
-        mod rt_impl;
-        pub use self::rt_impl::{
-            from_tcp_stream, from_unix_stream, tcp_connect, tcp_connect_in, unix_connect,
-            unix_connect_in,
-        };
-    } else {
-        pub use self::compat::*;
-    }
-}
-
-#[cfg(all(unix, feature = "neon"))]
-mod helpers;
+pub use self::compat::*;
--- a/ntex-net/src/rt_polling/connect.rs
+++ b/ntex-net/src/rt_polling/connect.rs
@ -1,111 +0,0 @@
-use std::os::fd::{AsRawFd, RawFd};
-use std::{cell::RefCell, io, rc::Rc, task::Poll};
-
-use ntex_neon::driver::{DriverApi, Event, Handler};
-use ntex_neon::{syscall, Runtime};
-use ntex_util::channel::oneshot::Sender;
-use slab::Slab;
-use socket2::SockAddr;
-
-#[derive(Clone)]
-pub(crate) struct ConnectOps(Rc<ConnectOpsInner>);
-
-#[derive(Debug)]
-enum Change {
-    Event(Event),
-    Error(io::Error),
-}
-
-struct ConnectOpsBatcher {
-    inner: Rc<ConnectOpsInner>,
-}
-
-struct Item {
-    fd: RawFd,
-    sender: Sender<io::Result<()>>,
-}
-
-struct ConnectOpsInner {
-    api: DriverApi,
-    connects: RefCell<Slab<Item>>,
-}
-
-impl ConnectOps {
-    pub(crate) fn current() -> Self {
-        Runtime::value(|rt| {
-            let mut inner = None;
-            rt.driver().register(|api| {
-                let ops = Rc::new(ConnectOpsInner {
-                    api,
-                    connects: RefCell::new(Slab::new()),
-                });
-                inner = Some(ops.clone());
-                Box::new(ConnectOpsBatcher { inner: ops })
-            });
-
-            ConnectOps(inner.unwrap())
-        })
-    }
-
-    pub(crate) fn connect(
-        &self,
-        fd: RawFd,
-        addr: SockAddr,
-        sender: Sender<io::Result<()>>,
-    ) -> io::Result<usize> {
-        let result = syscall!(break libc::connect(fd, addr.as_ptr(), addr.len()));
-
-        if let Poll::Ready(res) = result {
-            res?;
-        }
-
-        let item = Item { fd, sender };
-        let id = self.0.connects.borrow_mut().insert(item);
-
-        self.0.api.attach(fd, id as u32, Some(Event::writable(0)));
-        Ok(id)
-    }
-}
-
-impl Handler for ConnectOpsBatcher {
-    fn event(&mut self, id: usize, event: Event) {
-        log::debug!("connect-fd is readable {:?}", id);
-
-        let mut connects = self.inner.connects.borrow_mut();
-
-        if connects.contains(id) {
-            let item = connects.remove(id);
-            if event.writable {
-                let mut err: libc::c_int = 0;
-                let mut err_len = std::mem::size_of::<libc::c_int>() as libc::socklen_t;
-
-                let res = syscall!(libc::getsockopt(
-                    item.fd.as_raw_fd(),
-                    libc::SOL_SOCKET,
-                    libc::SO_ERROR,
-                    &mut err as *mut _ as *mut _,
-                    &mut err_len
-                ));
-
-                let res = if err == 0 {
-                    res.map(|_| ())
-                } else {
-                    Err(io::Error::from_raw_os_error(err))
-                };
-
-                self.inner.api.detach(item.fd, id as u32);
-                let _ = item.sender.send(res);
-            }
-        }
-    }
-
-    fn error(&mut self, id: usize, err: io::Error) {
-        let mut connects = self.inner.connects.borrow_mut();
-
-        if connects.contains(id) {
-            let item = connects.remove(id);
-            let _ = item.sender.send(Err(err));
-            self.inner.api.detach(item.fd, id as u32);
-        }
-    }
-}
--- a/ntex-net/src/rt_polling/driver.rs
+++ b/ntex-net/src/rt_polling/driver.rs
@ -1,368 +0,0 @@
-use std::os::fd::{AsRawFd, RawFd};
-use std::{cell::Cell, cell::RefCell, future::Future, io, mem, rc::Rc, task, task::Poll};
-
-use ntex_neon::driver::{DriverApi, Event, Handler};
-use ntex_neon::{syscall, Runtime};
-use slab::Slab;
-
-use ntex_bytes::BufMut;
-use ntex_io::IoContext;
-
-pub(crate) struct StreamCtl<T> {
-    id: u32,
-    inner: Rc<StreamOpsInner<T>>,
-}
-
-bitflags::bitflags! {
-    #[derive(Copy, Clone, Debug)]
-    struct Flags: u8 {
-        const RD     = 0b0000_0001;
-        const WR     = 0b0000_0010;
-    }
-}
-
-struct StreamItem<T> {
-    io: Option<T>,
-    fd: RawFd,
-    flags: Flags,
-    ref_count: u16,
-    context: IoContext,
-}
-
-pub(crate) struct StreamOps<T>(Rc<StreamOpsInner<T>>);
-
-struct StreamOpsHandler<T> {
-    inner: Rc<StreamOpsInner<T>>,
-}
-
-struct StreamOpsInner<T> {
-    api: DriverApi,
-    delayd_drop: Cell<bool>,
-    feed: RefCell<Vec<u32>>,
-    streams: Cell<Option<Box<Slab<StreamItem<T>>>>>,
-}
-
-impl<T> StreamItem<T> {
-    fn tag(&self) -> &'static str {
-        self.context.tag()
-    }
-}
-
-impl<T: AsRawFd + 'static> StreamOps<T> {
-    pub(crate) fn current() -> Self {
-        Runtime::value(|rt| {
-            let mut inner = None;
-            rt.driver().register(|api| {
-                let ops = Rc::new(StreamOpsInner {
-                    api,
-                    feed: RefCell::new(Vec::new()),
-                    delayd_drop: Cell::new(false),
-                    streams: Cell::new(Some(Box::new(Slab::new()))),
-                });
-                inner = Some(ops.clone());
-                Box::new(StreamOpsHandler { inner: ops })
-            });
-
-            StreamOps(inner.unwrap())
-        })
-    }
-
-    pub(crate) fn register(&self, io: T, context: IoContext) -> StreamCtl<T> {
-        let fd = io.as_raw_fd();
-        let stream = self.0.with(move |streams| {
-            let item = StreamItem {
-                fd,
-                context,
-                io: Some(io),
-                ref_count: 1,
-                flags: Flags::empty(),
-            };
-            StreamCtl {
-                id: streams.insert(item) as u32,
-                inner: self.0.clone(),
-            }
-        });
-
-        self.0.api.attach(
-            fd,
-            stream.id,
-            Some(Event::new(0, false, false).with_interrupt()),
-        );
-        stream
-    }
-}
-
-impl<T> Clone for StreamOps<T> {
-    fn clone(&self) -> Self {
-        Self(self.0.clone())
-    }
-}
-
-impl<T> Handler for StreamOpsHandler<T> {
-    fn event(&mut self, id: usize, ev: Event) {
-        self.inner.with(|streams| {
-            if !streams.contains(id) {
-                return;
-            }
-            let item = &mut streams[id];
-            if item.io.is_none() {
-                return;
-            }
-            log::debug!("{}: FD event {:?} event: {:?}", item.tag(), id, ev);
-
-            // handle HUP
-            if ev.is_interrupt() {
-                item.context.stopped(None);
-                close(id as u32, item, &self.inner.api, None, true);
-                return;
-            }
-
-            let mut renew_ev = Event::new(0, false, false).with_interrupt();
-
-            if ev.readable {
-                let res = item.context.with_read_buf(|buf| {
-                    let chunk = buf.chunk_mut();
-                    let result = task::ready!(syscall!(
-                        break libc::read(item.fd, chunk.as_mut_ptr() as _, chunk.len())
-                    ));
-                    if let Ok(size) = result {
-                        log::debug!("{}: data {:?}, s: {:?}", item.tag(), item.fd, size);
-                        unsafe { buf.advance_mut(size) };
-                    }
-                    Poll::Ready(result)
-                });
-
-                if res.is_pending() && item.context.is_read_ready() {
-                    renew_ev.readable = true;
-                    item.flags.insert(Flags::RD);
-                } else {
-                    item.flags.remove(Flags::RD);
-                }
-            } else if item.flags.contains(Flags::RD) {
-                renew_ev.readable = true;
-            }
-
-            if ev.writable {
-                let result = item.context.with_write_buf(|buf| {
-                    log::debug!("{}: write {:?} s: {:?}", item.tag(), item.fd, buf.len());
-                    syscall!(break libc::write(item.fd, buf[..].as_ptr() as _, buf.len()))
-                });
-                if result.is_pending() {
-                    renew_ev.writable = true;
-                    item.flags.insert(Flags::WR);
-                } else {
-                    item.flags.remove(Flags::WR);
-                }
-            } else if item.flags.contains(Flags::WR) {
-                renew_ev.writable = true;
-            }
-
-            self.inner.api.modify(item.fd, id as u32, renew_ev);
-
-            // delayed drops
-            if self.inner.delayd_drop.get() {
-                for id in self.inner.feed.borrow_mut().drain(..) {
-                    let item = &mut streams[id as usize];
-                    item.ref_count -= 1;
-                    if item.ref_count == 0 {
-                        let mut item = streams.remove(id as usize);
-                        log::debug!(
-                            "{}: Drop ({}), {:?}, has-io: {}",
-                            item.tag(),
-                            id,
-                            item.fd,
-                            item.io.is_some()
-                        );
-                        close(id, &mut item, &self.inner.api, None, true);
-                    }
-                }
-                self.inner.delayd_drop.set(false);
-            }
-        });
-    }
-
-    fn error(&mut self, id: usize, err: io::Error) {
-        self.inner.with(|streams| {
-            if let Some(item) = streams.get_mut(id) {
-                log::debug!(
-                    "{}: FD is failed ({}) {:?}, err: {:?}",
-                    item.tag(),
-                    id,
-                    item.fd,
-                    err
-                );
-                close(id as u32, item, &self.inner.api, Some(err), false);
-            }
-        })
-    }
-}
-
-impl<T> StreamOpsInner<T> {
-    fn with<F, R>(&self, f: F) -> R
-    where
-        F: FnOnce(&mut Slab<StreamItem<T>>) -> R,
-    {
-        let mut streams = self.streams.take().unwrap();
-        let result = f(&mut streams);
-        self.streams.set(Some(streams));
-        result
-    }
-}
-
-fn close<T>(
-    id: u32,
-    item: &mut StreamItem<T>,
-    api: &DriverApi,
-    error: Option<io::Error>,
-    shutdown: bool,
-) -> Option<ntex_rt::JoinHandle<io::Result<i32>>> {
-    if let Some(io) = item.io.take() {
-        log::debug!("{}: Closing ({}), {:?}", item.tag(), id, item.fd);
-        mem::forget(io);
-        if let Some(err) = error {
-            item.context.stopped(Some(err));
-        }
-        let fd = item.fd;
-        api.detach(fd, id);
-        Some(ntex_rt::spawn_blocking(move || {
-            if shutdown {
-                let _ = syscall!(libc::shutdown(fd, libc::SHUT_RDWR));
-            }
-            syscall!(libc::close(fd))
-        }))
-    } else {
-        None
-    }
-}
-
-impl<T> StreamCtl<T> {
-    pub(crate) fn close(self) -> impl Future<Output = io::Result<()>> {
-        let id = self.id as usize;
-        let fut = self.inner.with(|streams| {
-            let item = &mut streams[id];
-            close(self.id, item, &self.inner.api, None, false)
-        });
-        async move {
-            if let Some(fut) = fut {
-                fut.await
-                    .map_err(|e| io::Error::new(io::ErrorKind::Other, e))
-                    .and_then(crate::helpers::pool_io_err)?;
-            }
-            Ok(())
-        }
-    }
-
-    pub(crate) fn with_io<F, R>(&self, f: F) -> R
-    where
-        F: FnOnce(Option<&T>) -> R,
-    {
-        self.inner
-            .with(|streams| f(streams[self.id as usize].io.as_ref()))
-    }
-
-    pub(crate) fn modify(&self, rd: bool, wr: bool) {
-        self.inner.with(|streams| {
-            let item = &mut streams[self.id as usize];
-
-            log::debug!(
-                "{}: Modify interest ({}), {:?} rd: {:?}, wr: {:?}",
-                item.tag(),
-                self.id,
-                item.fd,
-                rd,
-                wr
-            );
-
-            let mut event = Event::new(0, false, false).with_interrupt();
-
-            if rd {
-                if item.flags.contains(Flags::RD) {
-                    event.readable = true;
-                } else {
-                    let res = item.context.with_read_buf(|buf| {
-                        let chunk = buf.chunk_mut();
-                        let result = task::ready!(syscall!(
-                            break libc::read(item.fd, chunk.as_mut_ptr() as _, chunk.len())
-                        ));
-                        if let Ok(size) = result {
-                            log::debug!(
-                                "{}: read {:?}, s: {:?}",
-                                item.tag(),
-                                item.fd,
-                                size
-                            );
-                            unsafe { buf.advance_mut(size) };
-                        }
-                        Poll::Ready(result)
-                    });
-
-                    if res.is_pending() && item.context.is_read_ready() {
-                        event.readable = true;
-                        item.flags.insert(Flags::RD);
-                    }
-                }
-            }
-
-            if wr {
-                if item.flags.contains(Flags::WR) {
-                    event.writable = true;
-                } else {
-                    let result = item.context.with_write_buf(|buf| {
-                        log::debug!(
-                            "{}: Writing ({}), buf: {:?}",
-                            item.tag(),
-                            self.id,
-                            buf.len()
-                        );
-                        syscall!(
-                            break libc::write(item.fd, buf[..].as_ptr() as _, buf.len())
-                        )
-                    });
-
-                    if result.is_pending() {
-                        event.writable = true;
-                        item.flags.insert(Flags::WR);
-                    }
-                }
-            }
-
-            self.inner.api.modify(item.fd, self.id, event);
-        })
-    }
-}
-
-impl<T> Clone for StreamCtl<T> {
-    fn clone(&self) -> Self {
-        self.inner.with(|streams| {
-            streams[self.id as usize].ref_count += 1;
-            Self {
-                id: self.id,
-                inner: self.inner.clone(),
-            }
-        })
-    }
-}
-
-impl<T> Drop for StreamCtl<T> {
-    fn drop(&mut self) {
-        if let Some(mut streams) = self.inner.streams.take() {
-            let id = self.id as usize;
-            streams[id].ref_count -= 1;
-            if streams[id].ref_count == 0 {
-                let mut item = streams.remove(id);
-                log::debug!(
-                    "{}:  Drop io ({}), {:?}, has-io: {}",
-                    item.tag(),
-                    self.id,
-                    item.fd,
-                    item.io.is_some()
-                );
-                close(self.id, &mut item, &self.inner.api, None, true);
-            }
-            self.inner.streams.set(Some(streams));
-        } else {
-            self.inner.delayd_drop.set(true);
-            self.inner.feed.borrow_mut().push(self.id);
-        }
-    }
-}
--- a/ntex-net/src/rt_polling/io.rs
+++ b/ntex-net/src/rt_polling/io.rs
@ -1,101 +0,0 @@
-use std::{any, future::poll_fn, task::Poll};
-
-use ntex_io::{
-    types, Handle, IoContext, IoStream, ReadContext, ReadStatus, WriteContext, WriteStatus,
-};
-use ntex_rt::spawn;
-use socket2::Socket;
-
-use super::driver::{StreamCtl, StreamOps};
-
-impl IoStream for super::TcpStream {
-    fn start(self, read: ReadContext, _: WriteContext) -> Option<Box<dyn Handle>> {
-        let io = self.0;
-        let context = read.context();
-        let ctl = StreamOps::current().register(io, context.clone());
-        let ctl2 = ctl.clone();
-        spawn(async move { run(ctl, context).await });
-
-        Some(Box::new(HandleWrapper(ctl2)))
-    }
-}
-
-impl IoStream for super::UnixStream {
-    fn start(self, read: ReadContext, _: WriteContext) -> Option<Box<dyn Handle>> {
-        let io = self.0;
-        let context = read.context();
-        let ctl = StreamOps::current().register(io, context.clone());
-        spawn(async move { run(ctl, context).await });
-
-        None
-    }
-}
-
-struct HandleWrapper(StreamCtl<Socket>);
-
-impl Handle for HandleWrapper {
-    fn query(&self, id: any::TypeId) -> Option<Box<dyn any::Any>> {
-        if id == any::TypeId::of::<types::PeerAddr>() {
-            let addr = self.0.with_io(|io| io.and_then(|io| io.peer_addr().ok()));
-            if let Some(addr) = addr.and_then(|addr| addr.as_socket()) {
-                return Some(Box::new(types::PeerAddr(addr)));
-            }
-        }
-        None
-    }
-}
-
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-enum Status {
-    Shutdown,
-    Terminate,
-}
-
-async fn run<T>(ctl: StreamCtl<T>, context: IoContext) {
-    // Handle io read readiness
-    let st = poll_fn(|cx| {
-        let mut modify = false;
-        let mut readable = false;
-        let mut writable = false;
-        let read = match context.poll_read_ready(cx) {
-            Poll::Ready(ReadStatus::Ready) => {
-                modify = true;
-                readable = true;
-                Poll::Pending
-            }
-            Poll::Ready(ReadStatus::Terminate) => Poll::Ready(()),
-            Poll::Pending => {
-                modify = true;
-                Poll::Pending
-            }
-        };
-
-        let write = match context.poll_write_ready(cx) {
-            Poll::Ready(WriteStatus::Ready) => {
-                modify = true;
-                writable = true;
-                Poll::Pending
-            }
-            Poll::Ready(WriteStatus::Shutdown) => Poll::Ready(Status::Shutdown),
-            Poll::Ready(WriteStatus::Terminate) => Poll::Ready(Status::Terminate),
-            Poll::Pending => Poll::Pending,
-        };
-
-        if modify {
-            ctl.modify(readable, writable);
-        }
-
-        if read.is_pending() && write.is_pending() {
-            Poll::Pending
-        } else if write.is_ready() {
-            write
-        } else {
-            Poll::Ready(Status::Terminate)
-        }
-    })
-    .await;
-
-    ctl.modify(false, true);
-    context.shutdown(st == Status::Shutdown).await;
-    context.stopped(ctl.close().await.err());
-}
--- a/ntex-net/src/rt_polling/mod.rs
+++ b/ntex-net/src/rt_polling/mod.rs
@ -1,69 +0,0 @@
-use std::{io::Result, net, net::SocketAddr};
-
-use ntex_bytes::PoolRef;
-use ntex_io::Io;
-use socket2::Socket;
-
-pub(crate) mod connect;
-mod driver;
-mod io;
-
-#[cfg(not(target_pointer_width = "64"))]
-compile_error!("Only 64bit platforms are supported");
-
-/// Tcp stream wrapper for neon TcpStream
-struct TcpStream(socket2::Socket);
-
-/// Tcp stream wrapper for neon UnixStream
-struct UnixStream(socket2::Socket);
-
-/// Opens a TCP connection to a remote host.
-pub async fn tcp_connect(addr: SocketAddr) -> Result<Io> {
-    let sock = crate::helpers::connect(addr).await?;
-    Ok(Io::new(TcpStream(crate::helpers::prep_socket(sock)?)))
-}
-
-/// Opens a TCP connection to a remote host and use specified memory pool.
-pub async fn tcp_connect_in(addr: SocketAddr, pool: PoolRef) -> Result<Io> {
-    let sock = crate::helpers::connect(addr).await?;
-    Ok(Io::with_memory_pool(
-        TcpStream(crate::helpers::prep_socket(sock)?),
-        pool,
-    ))
-}
-
-/// Opens a unix stream connection.
-pub async fn unix_connect<'a, P>(addr: P) -> Result<Io>
-where
-    P: AsRef<std::path::Path> + 'a,
-{
-    let sock = crate::helpers::connect_unix(addr).await?;
-    Ok(Io::new(UnixStream(crate::helpers::prep_socket(sock)?)))
-}
-
-/// Opens a unix stream connection and specified memory pool.
-pub async fn unix_connect_in<'a, P>(addr: P, pool: PoolRef) -> Result<Io>
-where
-    P: AsRef<std::path::Path> + 'a,
-{
-    let sock = crate::helpers::connect_unix(addr).await?;
-    Ok(Io::with_memory_pool(
-        UnixStream(crate::helpers::prep_socket(sock)?),
-        pool,
-    ))
-}
-
-/// Convert std TcpStream to TcpStream
-pub fn from_tcp_stream(stream: net::TcpStream) -> Result<Io> {
-    stream.set_nodelay(true)?;
-    Ok(Io::new(TcpStream(crate::helpers::prep_socket(
-        Socket::from(stream),
-    )?)))
-}
-
-/// Convert std UnixStream to UnixStream
-pub fn from_unix_stream(stream: std::os::unix::net::UnixStream) -> Result<Io> {
-    Ok(Io::new(UnixStream(crate::helpers::prep_socket(
-        Socket::from(stream),
-    )?)))
-}
--- a/ntex-net/src/rt_uring/connect.rs
+++ b/ntex-net/src/rt_uring/connect.rs
@ -1,91 +0,0 @@
-use std::{cell::RefCell, io, os::fd::RawFd, rc::Rc};
-
-use io_uring::{opcode, types::Fd};
-use ntex_neon::{driver::DriverApi, driver::Handler, Runtime};
-use ntex_util::channel::oneshot::Sender;
-use slab::Slab;
-use socket2::SockAddr;
-
-#[derive(Clone)]
-pub(crate) struct ConnectOps(Rc<ConnectOpsInner>);
-
-#[derive(Debug)]
-enum Change {
-    Readable,
-    Writable,
-    Error(io::Error),
-}
-
-struct ConnectOpsHandler {
-    inner: Rc<ConnectOpsInner>,
-}
-
-type Operations = RefCell<Slab<(Box<SockAddr>, Sender<io::Result<()>>)>>;
-
-struct ConnectOpsInner {
-    api: DriverApi,
-    ops: Operations,
-}
-
-impl ConnectOps {
-    pub(crate) fn current() -> Self {
-        Runtime::value(|rt| {
-            let mut inner = None;
-            rt.driver().register(|api| {
-                if !api.is_supported(opcode::Connect::CODE) {
-                    panic!("opcode::Connect is required for io-uring support");
-                }
-
-                let ops = Rc::new(ConnectOpsInner {
-                    api,
-                    ops: RefCell::new(Slab::new()),
-                });
-                inner = Some(ops.clone());
-                Box::new(ConnectOpsHandler { inner: ops })
-            });
-            ConnectOps(inner.unwrap())
-        })
-    }
-
-    pub(crate) fn connect(
-        &self,
-        fd: RawFd,
-        addr: SockAddr,
-        sender: Sender<io::Result<()>>,
-    ) -> io::Result<()> {
-        let addr2 = addr.clone();
-        let mut ops = self.0.ops.borrow_mut();
-
-        // addr must be stable, neon submits ops at the end of rt turn
-        let addr = Box::new(addr);
-        let (addr_ptr, addr_len) = (addr.as_ref().as_ptr(), addr.len());
-
-        let id = ops.insert((addr, sender));
-        self.0.api.submit(
-            id as u32,
-            opcode::Connect::new(Fd(fd), addr_ptr, addr_len).build(),
-        );
-
-        Ok(())
-    }
-}
-
-impl Handler for ConnectOpsHandler {
-    fn canceled(&mut self, user_data: usize) {
-        log::debug!("connect-op is canceled {:?}", user_data);
-
-        self.inner.ops.borrow_mut().remove(user_data);
-    }
-
-    fn completed(&mut self, user_data: usize, flags: u32, result: io::Result<i32>) {
-        let (addr, tx) = self.inner.ops.borrow_mut().remove(user_data);
-        log::debug!(
-            "connect-op is completed {:?} result: {:?}, addr: {:?}",
-            user_data,
-            result,
-            addr.as_socket()
-        );
-
-        let _ = tx.send(result.map(|_| ()));
-    }
-}
--- a/ntex-net/src/rt_uring/driver.rs
+++ b/ntex-net/src/rt_uring/driver.rs
@ -1,444 +0,0 @@
-use std::{cell::RefCell, io, mem, num::NonZeroU32, os, rc::Rc, task::Poll};
-
-use io_uring::{opcode, squeue::Entry, types::Fd};
-use ntex_neon::{driver::DriverApi, driver::Handler, Runtime};
-use ntex_util::channel::oneshot;
-use slab::Slab;
-
-use ntex_bytes::{Buf, BufMut, BytesVec};
-use ntex_io::IoContext;
-
-pub(crate) struct StreamCtl<T> {
-    id: usize,
-    inner: Rc<StreamOpsInner<T>>,
-}
-
-bitflags::bitflags! {
-    #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
-    struct Flags: u8 {
-        const RD_CANCELING = 0b0000_0001;
-        const RD_REISSUE   = 0b0000_0010;
-        const WR_CANCELING = 0b0001_0000;
-        const WR_REISSUE   = 0b0010_0000;
-    }
-}
-
-struct StreamItem<T> {
-    io: Option<T>,
-    fd: Fd,
-    context: IoContext,
-    ref_count: usize,
-    flags: Flags,
-    rd_op: Option<NonZeroU32>,
-    wr_op: Option<NonZeroU32>,
-}
-
-impl<T> StreamItem<T> {
-    fn tag(&self) -> &'static str {
-        self.context.tag()
-    }
-}
-
-enum Operation {
-    Recv {
-        id: usize,
-        buf: BytesVec,
-        context: IoContext,
-    },
-    Send {
-        id: usize,
-        buf: BytesVec,
-        context: IoContext,
-    },
-    Close {
-        tx: Option<oneshot::Sender<io::Result<i32>>>,
-    },
-    Nop,
-}
-
-pub(crate) struct StreamOps<T>(Rc<StreamOpsInner<T>>);
-
-struct StreamOpsHandler<T> {
-    inner: Rc<StreamOpsInner<T>>,
-}
-
-struct StreamOpsInner<T> {
-    api: DriverApi,
-    feed: RefCell<Vec<usize>>,
-    storage: RefCell<StreamOpsStorage<T>>,
-}
-
-struct StreamOpsStorage<T> {
-    ops: Slab<Operation>,
-    streams: Slab<StreamItem<T>>,
-}
-
-impl<T: os::fd::AsRawFd + 'static> StreamOps<T> {
-    pub(crate) fn current() -> Self {
-        Runtime::value(|rt| {
-            let mut inner = None;
-            rt.driver().register(|api| {
-                if !api.is_supported(opcode::Recv::CODE) {
-                    panic!("opcode::Recv is required for io-uring support");
-                }
-                if !api.is_supported(opcode::Send::CODE) {
-                    panic!("opcode::Send is required for io-uring support");
-                }
-                if !api.is_supported(opcode::Close::CODE) {
-                    panic!("opcode::Close is required for io-uring support");
-                }
-
-                let mut ops = Slab::new();
-                ops.insert(Operation::Nop);
-
-                let ops = Rc::new(StreamOpsInner {
-                    api,
-                    feed: RefCell::new(Vec::new()),
-                    storage: RefCell::new(StreamOpsStorage {
-                        ops,
-                        streams: Slab::new(),
-                    }),
-                });
-                inner = Some(ops.clone());
-                Box::new(StreamOpsHandler { inner: ops })
-            });
-
-            StreamOps(inner.unwrap())
-        })
-    }
-
-    pub(crate) fn register(&self, io: T, context: IoContext) -> StreamCtl<T> {
-        let item = StreamItem {
-            context,
-            fd: Fd(io.as_raw_fd()),
-            io: Some(io),
-            ref_count: 1,
-            rd_op: None,
-            wr_op: None,
-            flags: Flags::empty(),
-        };
-        let id = self.0.storage.borrow_mut().streams.insert(item);
-        StreamCtl {
-            id,
-            inner: self.0.clone(),
-        }
-    }
-
-    fn with<F, R>(&self, f: F) -> R
-    where
-        F: FnOnce(&mut StreamOpsStorage<T>) -> R,
-    {
-        f(&mut *self.0.storage.borrow_mut())
-    }
-}
-
-impl<T> Clone for StreamOps<T> {
-    fn clone(&self) -> Self {
-        Self(self.0.clone())
-    }
-}
-
-impl<T> Handler for StreamOpsHandler<T> {
-    fn canceled(&mut self, user_data: usize) {
-        let mut storage = self.inner.storage.borrow_mut();
-
-        match storage.ops.remove(user_data) {
-            Operation::Recv { id, buf, context } => {
-                log::debug!("{}: Recv canceled {:?}", context.tag(), id);
-                context.release_read_buf(buf);
-                if let Some(item) = storage.streams.get_mut(id) {
-                    item.rd_op.take();
-                    item.flags.remove(Flags::RD_CANCELING);
-                    if item.flags.contains(Flags::RD_REISSUE) {
-                        item.flags.remove(Flags::RD_REISSUE);
-
-                        let result = storage.recv(id, Some(context));
-                        if let Some((id, op)) = result {
-                            self.inner.api.submit(id, op);
-                        }
-                    }
-                }
-            }
-            Operation::Send { id, buf, context } => {
-                log::debug!("{}: Send canceled: {:?}", context.tag(), id);
-                context.release_write_buf(buf);
-                if let Some(item) = storage.streams.get_mut(id) {
-                    item.wr_op.take();
-                    item.flags.remove(Flags::WR_CANCELING);
-                    if item.flags.contains(Flags::WR_REISSUE) {
-                        item.flags.remove(Flags::WR_REISSUE);
-
-                        let result = storage.send(id, Some(context));
-                        if let Some((id, op)) = result {
-                            self.inner.api.submit(id, op);
-                        }
-                    }
-                }
-            }
-            Operation::Nop | Operation::Close { .. } => {}
-        }
-    }
-
-    fn completed(&mut self, user_data: usize, flags: u32, result: io::Result<i32>) {
-        let mut storage = self.inner.storage.borrow_mut();
-
-        let op = storage.ops.remove(user_data);
-        match op {
-            Operation::Recv {
-                id,
-                mut buf,
-                context,
-            } => {
-                let result = result.map(|size| {
-                    unsafe { buf.advance_mut(size as usize) };
-                    size as usize
-                });
-
-                // reset op reference
-                if let Some(item) = storage.streams.get_mut(id) {
-                    log::debug!(
-                        "{}: Recv completed {:?}, res: {:?}, buf({})",
-                        context.tag(),
-                        item.fd,
-                        result,
-                        buf.remaining_mut()
-                    );
-                    item.rd_op.take();
-                }
-
-                // set read buf
-                let tag = context.tag();
-                if context.set_read_buf(result, buf).is_pending() {
-                    if let Some((id, op)) = storage.recv(id, Some(context)) {
-                        self.inner.api.submit(id, op);
-                    }
-                } else {
-                    log::debug!("{}: Recv to pause", tag);
-                }
-            }
-            Operation::Send { id, buf, context } => {
-                // reset op reference
-                let fd = if let Some(item) = storage.streams.get_mut(id) {
-                    log::debug!(
-                        "{}: Send completed: {:?}, res: {:?}, buf({})",
-                        context.tag(),
-                        item.fd,
-                        result,
-                        buf.len()
-                    );
-                    item.wr_op.take();
-                    Some(item.fd)
-                } else {
-                    None
-                };
-
-                // set read buf
-                let result = context.set_write_buf(result.map(|size| size as usize), buf);
-                if result.is_pending() {
-                    log::debug!("{}: Need to send more: {:?}", context.tag(), fd);
-                    if let Some((id, op)) = storage.send(id, Some(context)) {
-                        self.inner.api.submit(id, op);
-                    }
-                }
-            }
-            Operation::Close { tx } => {
-                if let Some(tx) = tx {
-                    let _ = tx.send(result);
-                }
-            }
-            Operation::Nop => {}
-        }
-
-        // extra
-        for id in self.inner.feed.borrow_mut().drain(..) {
-            storage.streams[id].ref_count -= 1;
-            if storage.streams[id].ref_count == 0 {
-                let mut item = storage.streams.remove(id);
-
-                log::debug!("{}: Drop io ({}), {:?}", item.tag(), id, item.fd);
-
-                if let Some(io) = item.io.take() {
-                    mem::forget(io);
-
-                    let id = storage.ops.insert(Operation::Close { tx: None });
-                    assert!(id < u32::MAX as usize);
-                    self.inner
-                        .api
-                        .submit(id as u32, opcode::Close::new(item.fd).build());
-                }
-            }
-        }
-    }
-}
-
-impl<T> StreamOpsStorage<T> {
-    fn recv(&mut self, id: usize, context: Option<IoContext>) -> Option<(u32, Entry)> {
-        let item = &mut self.streams[id];
-
-        if item.rd_op.is_none() {
-            if let Poll::Ready(mut buf) = item.context.get_read_buf() {
-                log::debug!(
-                    "{}: Recv resume ({}), {:?} rem: {:?}",
-                    item.tag(),
-                    id,
-                    item.fd,
-                    buf.remaining_mut()
-                );
-
-                let slice = buf.chunk_mut();
-                let op = opcode::Recv::new(item.fd, slice.as_mut_ptr(), slice.len() as u32)
-                    .build();
-
-                let op_id = self.ops.insert(Operation::Recv {
-                    id,
-                    buf,
-                    context: context.unwrap_or_else(|| item.context.clone()),
-                });
-                assert!(op_id < u32::MAX as usize);
-
-                item.rd_op = NonZeroU32::new(op_id as u32);
-                return Some((op_id as u32, op));
-            }
-        } else if item.flags.contains(Flags::RD_CANCELING) {
-            item.flags.insert(Flags::RD_REISSUE);
-        }
-        None
-    }
-
-    fn send(&mut self, id: usize, context: Option<IoContext>) -> Option<(u32, Entry)> {
-        let item = &mut self.streams[id];
-
-        if item.wr_op.is_none() {
-            if let Poll::Ready(buf) = item.context.get_write_buf() {
-                log::debug!(
-                    "{}: Send resume ({}), {:?} len: {:?}",
-                    item.tag(),
-                    id,
-                    item.fd,
-                    buf.len()
-                );
-
-                let slice = buf.chunk();
-                let op =
-                    opcode::Send::new(item.fd, slice.as_ptr(), slice.len() as u32).build();
-
-                let op_id = self.ops.insert(Operation::Send {
-                    id,
-                    buf,
-                    context: context.unwrap_or_else(|| item.context.clone()),
-                });
-                assert!(op_id < u32::MAX as usize);
-
-                item.wr_op = NonZeroU32::new(op_id as u32);
-                return Some((op_id as u32, op));
-            }
-        } else if item.flags.contains(Flags::WR_CANCELING) {
-            item.flags.insert(Flags::WR_REISSUE);
-        }
-        None
-    }
-}
-
-impl<T> StreamCtl<T> {
-    pub(crate) async fn close(self) -> io::Result<()> {
-        let result = {
-            let mut storage = self.inner.storage.borrow_mut();
-
-            let (io, fd) = {
-                let item = &mut storage.streams[self.id];
-                (item.io.take(), item.fd)
-            };
-            if let Some(io) = io {
-                mem::forget(io);
-
-                let (tx, rx) = oneshot::channel();
-                let id = storage.ops.insert(Operation::Close { tx: Some(tx) });
-                assert!(id < u32::MAX as usize);
-
-                drop(storage);
-                self.inner
-                    .api
-                    .submit(id as u32, opcode::Close::new(fd).build());
-                Some(rx)
-            } else {
-                None
-            }
-        };
-
-        if let Some(rx) = result {
-            rx.await
-                .map_err(|_| io::Error::new(io::ErrorKind::Other, "gone"))
-                .and_then(|item| item)
-                .map(|_| ())
-        } else {
-            Ok(())
-        }
-    }
-
-    pub(crate) fn with_io<F, R>(&self, f: F) -> R
-    where
-        F: FnOnce(Option<&T>) -> R,
-    {
-        f(self.inner.storage.borrow().streams[self.id].io.as_ref())
-    }
-
-    pub(crate) fn resume_read(&self) {
-        let result = self.inner.storage.borrow_mut().recv(self.id, None);
-        if let Some((id, op)) = result {
-            self.inner.api.submit(id, op);
-        }
-    }
-
-    pub(crate) fn resume_write(&self) {
-        let result = self.inner.storage.borrow_mut().send(self.id, None);
-        if let Some((id, op)) = result {
-            self.inner.api.submit(id, op);
-        }
-    }
-
-    pub(crate) fn pause_read(&self) {
-        let mut storage = self.inner.storage.borrow_mut();
-        let item = &mut storage.streams[self.id];
-
-        if let Some(rd_op) = item.rd_op {
-            if !item.flags.contains(Flags::RD_CANCELING) {
-                log::debug!("{}: Recv to pause ({}), {:?}", item.tag(), self.id, item.fd);
-                item.flags.insert(Flags::RD_CANCELING);
-                self.inner.api.cancel(rd_op.get());
-            }
-        }
-    }
-}
-
-impl<T> Clone for StreamCtl<T> {
-    fn clone(&self) -> Self {
-        self.inner.storage.borrow_mut().streams[self.id].ref_count += 1;
-        Self {
-            id: self.id,
-            inner: self.inner.clone(),
-        }
-    }
-}
-
-impl<T> Drop for StreamCtl<T> {
-    fn drop(&mut self) {
-        if let Ok(mut storage) = self.inner.storage.try_borrow_mut() {
-            storage.streams[self.id].ref_count -= 1;
-            if storage.streams[self.id].ref_count == 0 {
-                let mut item = storage.streams.remove(self.id);
-                if let Some(io) = item.io.take() {
-                    log::debug!("{}: Close io ({}), {:?}", item.tag(), self.id, item.fd);
-                    mem::forget(io);
-
-                    let id = storage.ops.insert(Operation::Close { tx: None });
-                    assert!(id < u32::MAX as usize);
-                    self.inner
-                        .api
-                        .submit(id as u32, opcode::Close::new(item.fd).build());
-                }
-            }
-        } else {
-            self.inner.feed.borrow_mut().push(self.id);
-        }
-    }
-}
--- a/ntex-net/src/rt_uring/io.rs
+++ b/ntex-net/src/rt_uring/io.rs
@ -1,95 +0,0 @@
-use std::{any, future::poll_fn, task::Poll};
-
-use ntex_io::{
-    types, Handle, IoContext, IoStream, ReadContext, ReadStatus, WriteContext, WriteStatus,
-};
-use ntex_rt::spawn;
-use socket2::Socket;
-
-use super::driver::{StreamCtl, StreamOps};
-
-impl IoStream for super::TcpStream {
-    fn start(self, read: ReadContext, _: WriteContext) -> Option<Box<dyn Handle>> {
-        let io = self.0;
-        let context = read.context();
-        let ctl = StreamOps::current().register(io, context.clone());
-        let ctl2 = ctl.clone();
-        spawn(async move { run(ctl, context).await });
-
-        Some(Box::new(HandleWrapper(ctl2)))
-    }
-}
-
-impl IoStream for super::UnixStream {
-    fn start(self, read: ReadContext, _: WriteContext) -> Option<Box<dyn Handle>> {
-        let io = self.0;
-        let context = read.context();
-        let ctl = StreamOps::current().register(io, context.clone());
-        spawn(async move { run(ctl, context).await });
-
-        None
-    }
-}
-
-struct HandleWrapper(StreamCtl<Socket>);
-
-impl Handle for HandleWrapper {
-    fn query(&self, id: any::TypeId) -> Option<Box<dyn any::Any>> {
-        if id == any::TypeId::of::<types::PeerAddr>() {
-            let addr = self.0.with_io(|io| io.and_then(|io| io.peer_addr().ok()));
-            if let Some(addr) = addr.and_then(|addr| addr.as_socket()) {
-                return Some(Box::new(types::PeerAddr(addr)));
-            }
-        }
-        None
-    }
-}
-
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-enum Status {
-    Shutdown,
-    Terminate,
-}
-
-async fn run<T>(ctl: StreamCtl<T>, context: IoContext) {
-    // Handle io readiness
-    let st = poll_fn(|cx| {
-        let read = match context.poll_read_ready(cx) {
-            Poll::Ready(ReadStatus::Ready) => {
-                ctl.resume_read();
-                Poll::Pending
-            }
-            Poll::Ready(ReadStatus::Terminate) => Poll::Ready(()),
-            Poll::Pending => {
-                ctl.pause_read();
-                Poll::Pending
-            }
-        };
-
-        let write = match context.poll_write_ready(cx) {
-            Poll::Ready(WriteStatus::Ready) => {
-                ctl.resume_write();
-                Poll::Pending
-            }
-            Poll::Ready(WriteStatus::Shutdown) => Poll::Ready(Status::Shutdown),
-            Poll::Ready(WriteStatus::Terminate) => Poll::Ready(Status::Terminate),
-            Poll::Pending => Poll::Pending,
-        };
-
-        if read.is_pending() && write.is_pending() {
-            Poll::Pending
-        } else if write.is_ready() {
-            write
-        } else {
-            Poll::Ready(Status::Terminate)
-        }
-    })
-    .await;
-
-    ctl.pause_read();
-    ctl.resume_write();
-    context.shutdown(st == Status::Shutdown).await;
-
-    let result = ctl.close().await;
-    context.stopped(result.err());
-}
--- a/ntex-net/src/rt_uring/mod.rs
+++ b/ntex-net/src/rt_uring/mod.rs
@ -1,66 +0,0 @@
-use std::{io::Result, net, net::SocketAddr};
-
-use ntex_bytes::PoolRef;
-use ntex_io::Io;
-use socket2::Socket;
-
-pub(crate) mod connect;
-mod driver;
-mod io;
-
-/// Tcp stream wrapper for neon TcpStream
-struct TcpStream(Socket);
-
-/// Tcp stream wrapper for neon UnixStream
-struct UnixStream(Socket);
-
-/// Opens a TCP connection to a remote host.
-pub async fn tcp_connect(addr: SocketAddr) -> Result<Io> {
-    let sock = crate::helpers::connect(addr).await?;
-    Ok(Io::new(TcpStream(crate::helpers::prep_socket(sock)?)))
-}
-
-/// Opens a TCP connection to a remote host and use specified memory pool.
-pub async fn tcp_connect_in(addr: SocketAddr, pool: PoolRef) -> Result<Io> {
-    let sock = crate::helpers::connect(addr).await?;
-    Ok(Io::with_memory_pool(
-        TcpStream(crate::helpers::prep_socket(sock)?),
-        pool,
-    ))
-}
-
-/// Opens a unix stream connection.
-pub async fn unix_connect<'a, P>(addr: P) -> Result<Io>
-where
-    P: AsRef<std::path::Path> + 'a,
-{
-    let sock = crate::helpers::connect_unix(addr).await?;
-    Ok(Io::new(UnixStream(crate::helpers::prep_socket(sock)?)))
-}
-
-/// Opens a unix stream connection and specified memory pool.
-pub async fn unix_connect_in<'a, P>(addr: P, pool: PoolRef) -> Result<Io>
-where
-    P: AsRef<std::path::Path> + 'a,
-{
-    let sock = crate::helpers::connect_unix(addr).await?;
-    Ok(Io::with_memory_pool(
-        UnixStream(crate::helpers::prep_socket(sock)?),
-        pool,
-    ))
-}
-
-/// Convert std TcpStream to tokio's TcpStream
-pub fn from_tcp_stream(stream: net::TcpStream) -> Result<Io> {
-    stream.set_nodelay(true)?;
-    Ok(Io::new(TcpStream(crate::helpers::prep_socket(
-        Socket::from(stream),
-    )?)))
-}
-
-/// Convert std UnixStream to tokio's UnixStream
-pub fn from_unix_stream(stream: std::os::unix::net::UnixStream) -> Result<Io> {
-    Ok(Io::new(UnixStream(crate::helpers::prep_socket(
-        Socket::from(stream),
-    )?)))
-}
--- a/ntex-router/src/lib.rs
+++ b/ntex-router/src/lib.rs
@ -1,4 +1,9 @@
-#![deny(warnings, unreachable_pub, missing_debug_implementations)]
+#![deny(
+    rust_2018_idioms,
+    warnings,
+    unreachable_pub,
+    missing_debug_implementations
+)]
 #![warn(nonstandard_style, future_incompatible)]

 //! Resource path matching library.
@ -37,7 +42,7 @@ impl ResourcePath for String {
    }
 }

-impl ResourcePath for &str {
+impl<'a> ResourcePath for &'a str {
    fn path(&self) -> &str {
        self
    }
@ -49,7 +54,7 @@ impl ResourcePath for ntex_bytes::ByteString {
    }
 }

-impl<T: ResourcePath> ResourcePath for &T {
+impl<'a, T: ResourcePath> ResourcePath for &'a T {
    fn path(&self) -> &str {
        (*self).path()
    }
@ -66,13 +71,13 @@ impl IntoPattern for String {
    }
 }

-impl IntoPattern for &String {
+impl<'a> IntoPattern for &'a String {
    fn patterns(&self) -> Vec<String> {
        vec![self.as_str().to_string()]
    }
 }

-impl IntoPattern for &str {
+impl<'a> IntoPattern for &'a str {
    fn patterns(&self) -> Vec<String> {
        vec![(*self).to_string()]
    }
--- a/ntex-router/src/quoter.rs
+++ b/ntex-router/src/quoter.rs
@ -63,5 +63,5 @@ fn from_hex(v: u8) -> Option<u8> {

 #[inline]
 fn restore_ch(d1: u8, d2: u8) -> Option<u8> {
-    from_hex(d1).and_then(|d1| from_hex(d2).map(move |d2| (d1 << 4) | d2))
+    from_hex(d1).and_then(|d1| from_hex(d2).map(move |d2| d1 << 4 | d2))
 }
--- a/ntex-rt/CHANGES.md
+++ b/ntex-rt/CHANGES.md
@ -1,45 +1,5 @@
 # Changes

-## [0.4.29] - 2025-03-26
-
-* Add Arbiter::get_value() helper method
-
-## [0.4.27] - 2025-03-14
-
-* Add srbiters pings ttl
-
-* Retrieves a list of all arbiters in the system
-
-* Add "neon" runtime support
-
-* Drop glommio support
-
-* Drop async-std support
-
-## [0.4.26] - 2025-03-12
-
-* Add Arbiter::spawn_with()
-
-## [0.4.25] - 2025-03-11
-
-* Adds Send bound to arbiter exec (#514)
-
-## [0.4.24] - 2025-01-03
-
-* Relax runtime requirements
-
-## [0.4.23] - 2024-12-10
-
-* Remove Unpin requirements for Arbiter::spawn()
-
-## [0.4.22] - 2024-12-01
-
-* Depend on individual compio packages
-
-## [0.4.21] - 2024-11-25
-
-* Update to compio 0.13
-
 ## [0.4.20] - 2024-10-17

 * Allow to skip runtime feature for clippy run
--- a/ntex-rt/Cargo.toml
+++ b/ntex-rt/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "ntex-rt"
-version = "0.4.29"
+version = "0.4.20"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "ntex runtime"
 keywords = ["network", "framework", "async", "futures"]
@ -20,26 +20,33 @@ path = "src/lib.rs"
 [features]
 default = []

+# glommio support
+glommio = ["glomm-io", "futures-channel"]
+
 # tokio support
 tokio = ["tok-io"]

 # compio support
-compio = ["compio-driver", "compio-runtime"]
+compio = ["comp-io"]

-# neon runtime
-neon = ["ntex-neon"]
+# async-std support
+async-std = ["async_std/unstable"]

 [dependencies]
 async-channel = "2"
-futures-timer = "3.0"
-oneshot = "0.1"
+futures-core = "0.3"
 log = "0.4"
+oneshot = "0.1"

-compio-driver = { version = "0.6", optional = true }
-compio-runtime = { version = "0.6", optional = true }
+async_std = { version = "1", package = "async-std", optional = true }
+comp-io = { version = "0.12", package = "compio", default-features = false, features = [
+    "runtime"
+], optional = true }
 tok-io = { version = "1", package = "tokio", default-features = false, features = [
    "rt",
    "net",
 ], optional = true }

-ntex-neon = { version = "0.1.14", optional = true }
+[target.'cfg(target_os = "linux")'.dependencies]
+glomm-io = { version = "0.9", package = "glommio", optional = true }
+futures-channel = { version = "0.3", optional = true }
--- a/ntex-rt/build.rs
+++ b/ntex-rt/build.rs
@ -1,21 +1,33 @@
 use std::{collections::HashSet, env};

 fn main() {
+    let mut clippy = false;
    let mut features = HashSet::<&'static str>::default();

-    for (key, _) in env::vars() {
+    for (key, val) in env::vars() {
        let _ = match key.as_ref() {
            "CARGO_FEATURE_COMPIO" => features.insert("compio"),
            "CARGO_FEATURE_TOKIO" => features.insert("tokio"),
-            "CARGO_FEATURE_NEON" => features.insert("neon"),
+            "CARGO_FEATURE_GLOMMIO" => features.insert("glommio"),
+            "CARGO_FEATURE_ASYNC_STD" => features.insert("async-std"),
+            "CARGO_CFG_FEATURE" => {
+                if val.contains("cargo-clippy") {
+                    clippy = true;
+                }
+                false
+            }
            _ => false,
        };
    }

-    if features.len() > 1 {
-        panic!(
-            "Only one runtime feature could be selected, current selection {:?}",
-            features
-        );
+    if !clippy {
+        if features.is_empty() {
+            panic!("Runtime must be selected '--feature=ntex/$runtime', available options are \"compio\", \"tokio\", \"async-std\", \"glommio\"");
+        } else if features.len() > 1 {
+            panic!(
+                "Only one runtime feature could be selected, current selection {:?}",
+                features
+            );
+        }
    }
 }
--- a/ntex-rt/src/arbiter.rs
+++ b/ntex-rt/src/arbiter.rs
@ -1,22 +1,27 @@
 #![allow(clippy::let_underscore_future)]
 use std::any::{Any, TypeId};
-use std::sync::{atomic::AtomicUsize, atomic::Ordering, Arc};
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::task::{ready, Context, Poll};
 use std::{cell::RefCell, collections::HashMap, fmt, future::Future, pin::Pin, thread};

 use async_channel::{unbounded, Receiver, Sender};
+use futures_core::stream::Stream;

-use crate::system::{FnExec, Id, System, SystemCommand};
+use crate::system::System;

 thread_local!(
    static ADDR: RefCell<Option<Arbiter>> = const { RefCell::new(None) };
    static STORAGE: RefCell<HashMap<TypeId, Box<dyn Any>>> = RefCell::new(HashMap::new());
 );

+type ServerCommandRx = Pin<Box<dyn Stream<Item = SystemCommand>>>;
+type ArbiterCommandRx = Pin<Box<dyn Stream<Item = ArbiterCommand>>>;
+
 pub(super) static COUNT: AtomicUsize = AtomicUsize::new(0);

 pub(super) enum ArbiterCommand {
    Stop,
-    Execute(Pin<Box<dyn Future<Output = ()> + Send>>),
+    Execute(Box<dyn Future<Output = ()> + Unpin + Send>),
    ExecuteFn(Box<dyn FnExec>),
 }

@ -26,16 +31,13 @@ pub(super) enum ArbiterCommand {
 /// When an Arbiter is created, it spawns a new OS thread, and
 /// hosts an event loop. Some Arbiter functions execute on the current thread.
 pub struct Arbiter {
-    id: usize,
-    pub(crate) sys_id: usize,
-    name: Arc<String>,
    sender: Sender<ArbiterCommand>,
    thread_handle: Option<thread::JoinHandle<()>>,
 }

 impl fmt::Debug for Arbiter {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "Arbiter({:?})", self.name.as_ref())
+        write!(f, "Arbiter")
    }
 }

@ -47,20 +49,26 @@ impl Default for Arbiter {

 impl Clone for Arbiter {
    fn clone(&self) -> Self {
-        Self::with_sender(self.sys_id, self.id, self.name.clone(), self.sender.clone())
+        Self::with_sender(self.sender.clone())
    }
 }

 impl Arbiter {
    #[allow(clippy::borrowed_box)]
-    pub(super) fn new_system(name: String) -> (Self, ArbiterController) {
+    pub(super) fn new_system() -> (Self, ArbiterController) {
        let (tx, rx) = unbounded();

-        let arb = Arbiter::with_sender(0, 0, Arc::new(name), tx);
+        let arb = Arbiter::with_sender(tx);
        ADDR.with(|cell| *cell.borrow_mut() = Some(arb.clone()));
        STORAGE.with(|cell| cell.borrow_mut().clear());

-        (arb, ArbiterController { rx, stop: None })
+        (
+            arb,
+            ArbiterController {
+                stop: None,
+                rx: Box::pin(rx),
+            },
+        )
    }

    /// Returns the current thread's arbiter's address. If no Arbiter is present, then this
@ -77,37 +85,27 @@ impl Arbiter {
        let _ = self.sender.try_send(ArbiterCommand::Stop);
    }

-    /// Spawn new thread and run runtime in spawned thread.
+    /// Spawn new thread and run event loop in spawned thread.
    /// Returns address of newly created arbiter.
    pub fn new() -> Arbiter {
-        let name = format!("ntex-rt:worker:{}", COUNT.load(Ordering::Relaxed) + 1);
-        Arbiter::with_name(name)
-    }
-
-    /// Spawn new thread and run runtime in spawned thread.
-    /// Returns address of newly created arbiter.
-    pub fn with_name(name: String) -> Arbiter {
        let id = COUNT.fetch_add(1, Ordering::Relaxed);
+        let name = format!("ntex-rt:worker:{}", id);
        let sys = System::current();
-        let name2 = Arc::new(name.clone());
        let config = sys.config();
        let (arb_tx, arb_rx) = unbounded();
        let arb_tx2 = arb_tx.clone();

        let builder = if sys.config().stack_size > 0 {
            thread::Builder::new()
-                .name(name)
+                .name(name.clone())
                .stack_size(sys.config().stack_size)
        } else {
-            thread::Builder::new().name(name)
+            thread::Builder::new().name(name.clone())
        };

-        let name = name2.clone();
-        let sys_id = sys.id();
-
        let handle = builder
            .spawn(move || {
-                let arb = Arbiter::with_sender(sys_id.0, id, name2, arb_tx);
+                let arb = Arbiter::with_sender(arb_tx);

                let (stop, stop_rx) = oneshot::channel();
                STORAGE.with(|cell| cell.borrow_mut().clear());
@ -116,19 +114,16 @@ impl Arbiter {

                config.block_on(async move {
                    // start arbiter controller
-                    let _ = crate::spawn(
-                        ArbiterController {
-                            stop: Some(stop),
-                            rx: arb_rx,
-                        }
-                        .run(),
-                    );
+                    let _ = crate::spawn(ArbiterController {
+                        stop: Some(stop),
+                        rx: Box::pin(arb_rx),
+                    });
                    ADDR.with(|cell| *cell.borrow_mut() = Some(arb.clone()));

                    // register arbiter
                    let _ = System::current()
                        .sys()
-                        .try_send(SystemCommand::RegisterArbiter(Id(id), arb));
+                        .try_send(SystemCommand::RegisterArbiter(id, arb));

                    // run loop
                    let _ = stop_rx.await;
@ -137,84 +132,32 @@ impl Arbiter {
                // unregister arbiter
                let _ = System::current()
                    .sys()
-                    .try_send(SystemCommand::UnregisterArbiter(Id(id)));
+                    .try_send(SystemCommand::UnregisterArbiter(id));
            })
            .unwrap_or_else(|err| {
                panic!("Cannot spawn an arbiter's thread {:?}: {:?}", &name, err)
            });

        Arbiter {
-            id,
-            name,
-            sys_id: sys_id.0,
            sender: arb_tx2,
            thread_handle: Some(handle),
        }
    }

-    fn with_sender(
-        sys_id: usize,
-        id: usize,
-        name: Arc<String>,
-        sender: Sender<ArbiterCommand>,
-    ) -> Self {
-        Self {
-            id,
-            sys_id,
-            name,
-            sender,
-            thread_handle: None,
-        }
-    }
-
-    /// Id of the arbiter
-    pub fn id(&self) -> Id {
-        Id(self.id)
-    }
-
-    /// Name of the arbiter
-    pub fn name(&self) -> &str {
-        self.name.as_ref()
-    }
-
    /// Send a future to the Arbiter's thread, and spawn it.
    pub fn spawn<F>(&self, future: F)
    where
-        F: Future<Output = ()> + Send + 'static,
+        F: Future<Output = ()> + Send + Unpin + 'static,
    {
        let _ = self
            .sender
-            .try_send(ArbiterCommand::Execute(Box::pin(future)));
+            .try_send(ArbiterCommand::Execute(Box::new(future)));
    }

-    #[rustfmt::skip]
-    /// Send a function to the Arbiter's thread and spawns it's resulting future.
-    /// This can be used to spawn non-send futures on the arbiter thread.
-    pub fn spawn_with<F, R, O>(
-        &self,
-        f: F
-    ) -> impl Future<Output = Result<O, oneshot::RecvError>> + Send + 'static
-    where
-        F: FnOnce() -> R + Send + 'static,
-        R: Future<Output = O> + 'static,
-        O: Send + 'static,
-    {
-        let (tx, rx) = oneshot::channel();
-        let _ = self
-            .sender
-            .try_send(ArbiterCommand::ExecuteFn(Box::new(move || {
-                crate::spawn(async move {
-                    let _ = tx.send(f().await);
-                });
-            })));
-        rx
-    }
-
-    #[rustfmt::skip]
    /// Send a function to the Arbiter's thread. This function will be executed asynchronously.
    /// A future is created, and when resolved will contain the result of the function sent
    /// to the Arbiters thread.
-    pub fn exec<F, R>(&self, f: F) -> impl Future<Output = Result<R, oneshot::RecvError>> + Send + 'static
+    pub fn exec<F, R>(&self, f: F) -> impl Future<Output = Result<R, oneshot::RecvError>>
    where
        F: FnOnce() -> R + Send + 'static,
        R: Send + 'static,
@ -286,23 +229,11 @@ impl Arbiter {
        })
    }

-    /// Get a type previously inserted to this runtime or create new one.
-    pub fn get_value<T, F>(f: F) -> T
-    where
-        T: Clone + 'static,
-        F: FnOnce() -> T,
-    {
-        STORAGE.with(move |cell| {
-            let mut st = cell.borrow_mut();
-            if let Some(boxed) = st.get(&TypeId::of::<T>()) {
-                if let Some(val) = (&**boxed as &(dyn Any + 'static)).downcast_ref::<T>() {
-                    return val.clone();
-                }
-            }
-            let val = f();
-            st.insert(TypeId::of::<T>(), Box::new(val.clone()));
-            val
-        })
+    fn with_sender(sender: Sender<ArbiterCommand>) -> Self {
+        Self {
+            sender,
+            thread_handle: None,
+        }
    }

    /// Wait for the event loop to stop by joining the underlying thread (if have Some).
@ -315,17 +246,9 @@ impl Arbiter {
    }
 }

-impl Eq for Arbiter {}
-
-impl PartialEq for Arbiter {
-    fn eq(&self, other: &Self) -> bool {
-        self.id == other.id && self.sys_id == other.sys_id
-    }
-}
-
 pub(crate) struct ArbiterController {
    stop: Option<oneshot::Sender<i32>>,
-    rx: Receiver<ArbiterCommand>,
+    rx: ArbiterCommandRx,
 }

 impl Drop for ArbiterController {
@ -341,28 +264,118 @@ impl Drop for ArbiterController {
    }
 }

-impl ArbiterController {
-    pub(super) async fn run(mut self) {
+impl Future for ArbiterController {
+    type Output = ();
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        loop {
-            match self.rx.recv().await {
-                Ok(ArbiterCommand::Stop) => {
-                    if let Some(stop) = self.stop.take() {
-                        let _ = stop.send(0);
-                    };
-                    break;
-                }
-                Ok(ArbiterCommand::Execute(fut)) => {
-                    let _ = crate::spawn(fut);
-                }
-                Ok(ArbiterCommand::ExecuteFn(f)) => {
-                    f.call_box();
-                }
-                Err(_) => break,
+            match Pin::new(&mut self.rx).poll_next(cx) {
+                Poll::Ready(None) => return Poll::Ready(()),
+                Poll::Ready(Some(item)) => match item {
+                    ArbiterCommand::Stop => {
+                        if let Some(stop) = self.stop.take() {
+                            let _ = stop.send(0);
+                        };
+                        return Poll::Ready(());
+                    }
+                    ArbiterCommand::Execute(fut) => {
+                        let _ = crate::spawn(fut);
+                    }
+                    ArbiterCommand::ExecuteFn(f) => {
+                        f.call_box();
+                    }
+                },
+                Poll::Pending => return Poll::Pending,
            }
        }
    }
 }

+#[derive(Debug)]
+pub(super) enum SystemCommand {
+    Exit(i32),
+    RegisterArbiter(usize, Arbiter),
+    UnregisterArbiter(usize),
+}
+
+pub(super) struct SystemArbiter {
+    stop: Option<oneshot::Sender<i32>>,
+    commands: ServerCommandRx,
+    arbiters: HashMap<usize, Arbiter>,
+}
+
+impl SystemArbiter {
+    pub(super) fn new(
+        stop: oneshot::Sender<i32>,
+        commands: Receiver<SystemCommand>,
+    ) -> Self {
+        SystemArbiter {
+            commands: Box::pin(commands),
+            stop: Some(stop),
+            arbiters: HashMap::new(),
+        }
+    }
+}
+
+impl fmt::Debug for SystemArbiter {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("SystemArbiter")
+            .field("arbiters", &self.arbiters)
+            .finish()
+    }
+}
+
+impl Future for SystemArbiter {
+    type Output = ();
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        loop {
+            let cmd = ready!(Pin::new(&mut self.commands).poll_next(cx));
+            log::debug!("Received system command: {:?}", cmd);
+            match cmd {
+                None => {
+                    log::debug!("System stopped");
+                    return Poll::Ready(());
+                }
+                Some(cmd) => match cmd {
+                    SystemCommand::Exit(code) => {
+                        log::debug!("Stopping system with {} code", code);
+
+                        // stop arbiters
+                        for arb in self.arbiters.values() {
+                            arb.stop();
+                        }
+                        // stop event loop
+                        if let Some(stop) = self.stop.take() {
+                            let _ = stop.send(code);
+                        }
+                    }
+                    SystemCommand::RegisterArbiter(name, hnd) => {
+                        self.arbiters.insert(name, hnd);
+                    }
+                    SystemCommand::UnregisterArbiter(name) => {
+                        self.arbiters.remove(&name);
+                    }
+                },
+            }
+        }
+    }
+}
+
+pub(super) trait FnExec: Send + 'static {
+    fn call_box(self: Box<Self>);
+}
+
+impl<F> FnExec for F
+where
+    F: FnOnce() + Send + 'static,
+{
+    #[allow(clippy::boxed_local)]
+    fn call_box(self: Box<Self>) {
+        (*self)()
+    }
+}
+
 #[cfg(test)]
 mod tests {
    use super::*;
@ -374,7 +387,6 @@ mod tests {
        assert!(Arbiter::get_item::<&'static str, _, _>(|s| *s == "test"));
        assert!(Arbiter::get_mut_item::<&'static str, _, _>(|s| *s == "test"));
        assert!(Arbiter::contains_item::<&'static str>());
-        assert!(Arbiter::get_value(|| 64u64) == 64);
        assert!(format!("{:?}", Arbiter::current()).contains("Arbiter"));
    }
 }
--- a/ntex-rt/src/builder.rs
+++ b/ntex-rt/src/builder.rs
@ -1,9 +1,9 @@
-use std::{future::Future, io, marker::PhantomData, pin::Pin, rc::Rc, sync::Arc};
+use std::{future::Future, io, pin::Pin, sync::Arc};

 use async_channel::unbounded;

-use crate::arbiter::{Arbiter, ArbiterController};
-use crate::system::{System, SystemCommand, SystemConfig, SystemSupport};
+use crate::arbiter::{Arbiter, ArbiterController, SystemArbiter};
+use crate::{system::SystemConfig, System};

 /// Builder struct for a ntex runtime.
 ///
@ -17,8 +17,6 @@ pub struct Builder {
    stop_on_panic: bool,
    /// New thread stack size
    stack_size: usize,
-    /// Arbiters ping interval
-    ping_interval: usize,
    /// Block on fn
    block_on: Option<Arc<dyn Fn(Pin<Box<dyn Future<Output = ()>>>) + Sync + Send>>,
 }
@ -30,7 +28,6 @@ impl Builder {
            stop_on_panic: false,
            stack_size: 0,
            block_on: None,
-            ping_interval: 1000,
        }
    }

@ -55,15 +52,6 @@ impl Builder {
        self
    }

-    /// Sets ping interval for spawned arbiters.
-    ///
-    /// Interval is in milliseconds. By default 5000 milliseconds is set.
-    /// To disable pings set value to zero.
-    pub fn ping_interval(mut self, interval: usize) -> Self {
-        self.ping_interval = interval;
-        self
-    }
-
    /// Use custom block_on function
    pub fn block_on<F>(mut self, block_on: F) -> Self
    where
@ -86,20 +74,18 @@ impl Builder {
            stop_on_panic: self.stop_on_panic,
        };

-        let (arb, controller) = Arbiter::new_system(self.name.clone());
-        let _ = sys_sender.try_send(SystemCommand::RegisterArbiter(arb.id(), arb.clone()));
-        let system = System::construct(sys_sender, arb.clone(), config);
+        let (arb, arb_controller) = Arbiter::new_system();
+        let system = System::construct(sys_sender, arb, config);

        // system arbiter
-        let support = SystemSupport::new(stop_tx, sys_receiver, self.ping_interval);
+        let arb = SystemArbiter::new(stop_tx, sys_receiver);

        // init system arbiter and run configuration method
        SystemRunner {
            stop,
-            support,
-            controller,
+            arb,
+            arb_controller,
            system,
-            _t: PhantomData,
        }
    }
 }
@ -108,10 +94,9 @@ impl Builder {
 #[must_use = "SystemRunner must be run"]
 pub struct SystemRunner {
    stop: oneshot::Receiver<i32>,
-    support: SystemSupport,
-    controller: ArbiterController,
+    arb: SystemArbiter,
+    arb_controller: ArbiterController,
    system: System,
-    _t: PhantomData<Rc<()>>,
 }

 impl SystemRunner {
@ -128,14 +113,15 @@ impl SystemRunner {

    /// This function will start event loop and will finish once the
    /// `System::stop()` function is called.
+    #[inline]
    pub fn run<F>(self, f: F) -> io::Result<()>
    where
        F: FnOnce() -> io::Result<()> + 'static,
    {
        let SystemRunner {
-            controller,
            stop,
-            support,
+            arb,
+            arb_controller,
            system,
            ..
        } = self;
@ -144,8 +130,8 @@ impl SystemRunner {
        system.config().block_on(async move {
            f()?;

-            let _ = crate::spawn(support.run());
-            let _ = crate::spawn(controller.run());
+            let _ = crate::spawn(arb);
+            let _ = crate::spawn(arb_controller);
            match stop.await {
                Ok(code) => {
                    if code != 0 {
@ -163,21 +149,22 @@ impl SystemRunner {
    }

    /// Execute a future and wait for result.
+    #[inline]
    pub fn block_on<F, R>(self, fut: F) -> R
    where
        F: Future<Output = R> + 'static,
        R: 'static,
    {
        let SystemRunner {
-            controller,
-            support,
+            arb,
+            arb_controller,
            system,
            ..
        } = self;

        system.config().block_on(async move {
-            let _ = crate::spawn(support.run());
-            let _ = crate::spawn(controller.run());
+            let _ = crate::spawn(arb);
+            let _ = crate::spawn(arb_controller);
            fut.await
        })
    }
@ -190,16 +177,16 @@ impl SystemRunner {
        R: 'static,
    {
        let SystemRunner {
-            controller,
-            support,
+            arb,
+            arb_controller,
            ..
        } = self;

        // run loop
        tok_io::task::LocalSet::new()
            .run_until(async move {
-                let _ = crate::spawn(support.run());
-                let _ = crate::spawn(controller.run());
+                let _ = crate::spawn(arb);
+                let _ = crate::spawn(arb_controller);
                fut.await
            })
            .await
@ -255,7 +242,6 @@ mod tests {
        thread::spawn(move || {
            let runner = crate::System::build()
                .stop_on_panic(true)
-                .ping_interval(25)
                .block_on(|fut| {
                    let rt = tok_io::runtime::Builder::new_current_thread()
                        .enable_all()
@ -284,18 +270,6 @@ mod tests {
            .unwrap();
        assert_eq!(id, id2);

-        let (tx, rx) = mpsc::channel();
-        sys.arbiter().spawn(async move {
-            futures_timer::Delay::new(std::time::Duration::from_millis(100)).await;
-
-            let recs = System::list_arbiter_pings(Arbiter::current().id(), |recs| {
-                recs.unwrap().clone()
-            });
-            let _ = tx.send(recs);
-        });
-        let recs = rx.recv().unwrap();
-
-        assert!(!recs.is_empty());
        sys.stop();
    }
 }
--- a/ntex-rt/src/lib.rs
+++ b/ntex-rt/src/lib.rs
@ -8,7 +8,7 @@ mod system;

 pub use self::arbiter::Arbiter;
 pub use self::builder::{Builder, SystemRunner};
-pub use self::system::{Id, PingRecord, System};
+pub use self::system::System;

 thread_local! {
    static CB: RefCell<(TBefore, TEnter, TExit, TAfter)> = RefCell::new((
@ -112,8 +112,6 @@ mod tokio {
    ///
    /// This function panics if ntex system is not running.
    #[inline]
-    #[doc(hidden)]
-    #[deprecated]
    pub fn spawn_fn<F, R>(f: F) -> tok_io::task::JoinHandle<R::Output>
    where
        F: FnOnce() -> R + 'static,
@ -129,14 +127,14 @@ mod compio {
    use std::task::{ready, Context, Poll};
    use std::{fmt, future::poll_fn, future::Future, pin::Pin};

-    use compio_runtime::Runtime;
+    use comp_io::runtime::Runtime;

    /// Runs the provided future, blocking the current thread until the future
    /// completes.
    pub fn block_on<F: Future<Output = ()>>(fut: F) {
        log::info!(
            "Starting compio runtime, driver {:?}",
-            compio_driver::DriverType::current()
+            comp_io::driver::DriverType::current()
        );
        let rt = Runtime::new().unwrap();
        rt.block_on(fut);
@ -153,7 +151,7 @@ mod compio {
        T: Send + 'static,
    {
        JoinHandle {
-            fut: Some(compio_runtime::spawn_blocking(f)),
+            fut: Some(comp_io::runtime::spawn_blocking(f)),
        }
    }

@ -170,7 +168,7 @@ mod compio {
        F: Future + 'static,
    {
        let ptr = crate::CB.with(|cb| (cb.borrow().0)());
-        let fut = compio_runtime::spawn(async move {
+        let fut = comp_io::runtime::spawn(async move {
            if let Some(ptr) = ptr {
                let mut f = std::pin::pin!(f);
                let result = poll_fn(|ctx| {
@ -198,8 +196,6 @@ mod compio {
    ///
    /// This function panics if ntex system is not running.
    #[inline]
-    #[doc(hidden)]
-    #[deprecated]
    pub fn spawn_fn<F, R>(f: F) -> JoinHandle<R::Output>
    where
        F: FnOnce() -> R + 'static,
@ -220,7 +216,7 @@ mod compio {
    impl std::error::Error for JoinError {}

    pub struct JoinHandle<T> {
-        fut: Option<compio_runtime::JoinHandle<T>>,
+        fut: Option<comp_io::runtime::JoinHandle<T>>,
    }

    impl<T> JoinHandle<T> {
@ -252,38 +248,15 @@ mod compio {
 }

 #[allow(dead_code)]
-#[cfg(feature = "neon")]
-mod neon {
-    use std::task::{ready, Context, Poll};
-    use std::{fmt, future::poll_fn, future::Future, pin::Pin};
-
-    use ntex_neon::Runtime;
+#[cfg(feature = "async-std")]
+mod asyncstd {
+    use std::future::{poll_fn, Future};
+    use std::{fmt, pin::Pin, task::ready, task::Context, task::Poll};

    /// Runs the provided future, blocking the current thread until the future
    /// completes.
    pub fn block_on<F: Future<Output = ()>>(fut: F) {
-        let rt = Runtime::new().unwrap();
-        log::info!(
-            "Starting neon runtime, driver {:?}",
-            rt.driver().tp().name()
-        );
-
-        rt.block_on(fut);
-    }
-
-    /// Spawns a blocking task.
-    ///
-    /// The task will be spawned onto a thread pool specifically dedicated
-    /// to blocking tasks. This is useful to prevent long-running synchronous
-    /// operations from blocking the main futures executor.
-    pub fn spawn_blocking<F, T>(f: F) -> JoinHandle<T>
-    where
-        F: FnOnce() -> T + Send + Sync + 'static,
-        T: Send + 'static,
-    {
-        JoinHandle {
-            fut: Some(ntex_neon::spawn_blocking(f)),
-        }
+        async_std::task::block_on(fut);
    }

    /// Spawn a future on the current thread. This does not create a new Arbiter
@ -294,29 +267,29 @@ mod neon {
    ///
    /// This function panics if ntex system is not running.
    #[inline]
-    pub fn spawn<F>(f: F) -> Task<F::Output>
+    pub fn spawn<F>(mut f: F) -> JoinHandle<F::Output>
    where
        F: Future + 'static,
    {
        let ptr = crate::CB.with(|cb| (cb.borrow().0)());
-        let task = ntex_neon::spawn(async move {
-            if let Some(ptr) = ptr {
-                let mut f = std::pin::pin!(f);
-                let result = poll_fn(|ctx| {
-                    let new_ptr = crate::CB.with(|cb| (cb.borrow().1)(ptr));
-                    let result = f.as_mut().poll(ctx);
-                    crate::CB.with(|cb| (cb.borrow().2)(new_ptr));
+        JoinHandle {
+            fut: async_std::task::spawn_local(async move {
+                if let Some(ptr) = ptr {
+                    let mut f = unsafe { Pin::new_unchecked(&mut f) };
+                    let result = poll_fn(|ctx| {
+                        let new_ptr = crate::CB.with(|cb| (cb.borrow().1)(ptr));
+                        let result = f.as_mut().poll(ctx);
+                        crate::CB.with(|cb| (cb.borrow().2)(new_ptr));
+                        result
+                    })
+                    .await;
+                    crate::CB.with(|cb| (cb.borrow().3)(ptr));
                    result
-                })
-                .await;
-                crate::CB.with(|cb| (cb.borrow().3)(ptr));
-                result
-            } else {
-                f.await
-            }
-        });
-
-        Task { task: Some(task) }
+                } else {
+                    f.await
+                }
+            }),
+        }
    }

    /// Executes a future on the current thread. This does not create a new Arbiter
@ -327,9 +300,7 @@ mod neon {
    ///
    /// This function panics if ntex system is not running.
    #[inline]
-    #[doc(hidden)]
-    #[deprecated]
-    pub fn spawn_fn<F, R>(f: F) -> Task<R::Output>
+    pub fn spawn_fn<F, R>(f: F) -> JoinHandle<R::Output>
    where
        F: FnOnce() -> R + 'static,
        R: Future + 'static,
@ -337,32 +308,18 @@ mod neon {
        spawn(async move { f().await })
    }

-    /// A spawned task.
-    pub struct Task<T> {
-        task: Option<ntex_neon::Task<T>>,
-    }
-
-    impl<T> Task<T> {
-        pub fn is_finished(&self) -> bool {
-            if let Some(hnd) = &self.task {
-                hnd.is_finished()
-            } else {
-                true
-            }
-        }
-    }
-
-    impl<T> Drop for Task<T> {
-        fn drop(&mut self) {
-            self.task.take().unwrap().detach();
-        }
-    }
-
-    impl<T> Future for Task<T> {
-        type Output = Result<T, JoinError>;
-
-        fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-            Poll::Ready(Ok(ready!(Pin::new(self.task.as_mut().unwrap()).poll(cx))))
+    /// Spawns a blocking task.
+    ///
+    /// The task will be spawned onto a thread pool specifically dedicated
+    /// to blocking tasks. This is useful to prevent long-running synchronous
+    /// operations from blocking the main futures executor.
+    pub fn spawn_blocking<F, T>(f: F) -> JoinHandle<T>
+    where
+        F: FnOnce() -> T + Send + 'static,
+        T: Send + 'static,
+    {
+        JoinHandle {
+            fut: async_std::task::spawn_blocking(f),
        }
    }

@ -378,24 +335,128 @@ mod neon {
    impl std::error::Error for JoinError {}

    pub struct JoinHandle<T> {
-        fut: Option<ntex_neon::JoinHandle<T>>,
-    }
-
-    impl<T> JoinHandle<T> {
-        pub fn is_finished(&self) -> bool {
-            self.fut.is_none()
-        }
+        fut: async_std::task::JoinHandle<T>,
    }

    impl<T> Future for JoinHandle<T> {
        type Output = Result<T, JoinError>;

        fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-            Poll::Ready(
-                ready!(Pin::new(self.fut.as_mut().unwrap()).poll(cx))
-                    .map_err(|_| JoinError)
-                    .and_then(|result| result.map_err(|_| JoinError)),
-            )
+            Poll::Ready(Ok(ready!(Pin::new(&mut self.fut).poll(cx))))
+        }
+    }
+}
+
+#[allow(dead_code)]
+#[cfg(all(feature = "glommio", target_os = "linux"))]
+mod glommio {
+    use std::future::{poll_fn, Future};
+    use std::{pin::Pin, task::Context, task::Poll};
+
+    use futures_channel::oneshot::Canceled;
+    use glomm_io::task;
+
+    pub type JoinError = Canceled;
+
+    /// Runs the provided future, blocking the current thread until the future
+    /// completes.
+    pub fn block_on<F: Future<Output = ()>>(fut: F) {
+        let ex = glomm_io::LocalExecutor::default();
+        ex.run(async move {
+            let _ = fut.await;
+        })
+    }
+
+    /// Spawn a future on the current thread. This does not create a new Arbiter
+    /// or Arbiter address, it is simply a helper for spawning futures on the current
+    /// thread.
+    ///
+    /// # Panics
+    ///
+    /// This function panics if ntex system is not running.
+    #[inline]
+    pub fn spawn<F>(mut f: F) -> JoinHandle<F::Output>
+    where
+        F: Future + 'static,
+        F::Output: 'static,
+    {
+        let ptr = crate::CB.with(|cb| (cb.borrow().0)());
+        JoinHandle {
+            fut: Either::Left(
+                glomm_io::spawn_local(async move {
+                    if let Some(ptr) = ptr {
+                        glomm_io::executor().yield_now().await;
+                        let mut f = unsafe { Pin::new_unchecked(&mut f) };
+                        let result = poll_fn(|ctx| {
+                            let new_ptr = crate::CB.with(|cb| (cb.borrow().1)(ptr));
+                            let result = f.as_mut().poll(ctx);
+                            crate::CB.with(|cb| (cb.borrow().2)(new_ptr));
+                            result
+                        })
+                        .await;
+                        crate::CB.with(|cb| (cb.borrow().3)(ptr));
+                        result
+                    } else {
+                        glomm_io::executor().yield_now().await;
+                        f.await
+                    }
+                })
+                .detach(),
+            ),
+        }
+    }
+
+    /// Executes a future on the current thread. This does not create a new Arbiter
+    /// or Arbiter address, it is simply a helper for executing futures on the current
+    /// thread.
+    ///
+    /// # Panics
+    ///
+    /// This function panics if ntex system is not running.
+    #[inline]
+    pub fn spawn_fn<F, R>(f: F) -> JoinHandle<R::Output>
+    where
+        F: FnOnce() -> R + 'static,
+        R: Future + 'static,
+    {
+        spawn(async move { f().await })
+    }
+
+    pub fn spawn_blocking<F, R>(f: F) -> JoinHandle<R>
+    where
+        F: FnOnce() -> R + Send + 'static,
+        R: Send + 'static,
+    {
+        let fut = glomm_io::executor().spawn_blocking(f);
+        JoinHandle {
+            fut: Either::Right(Box::pin(async move { Ok(fut.await) })),
+        }
+    }
+
+    enum Either<T1, T2> {
+        Left(T1),
+        Right(T2),
+    }
+
+    /// Blocking operation completion future. It resolves with results
+    /// of blocking function execution.
+    #[allow(clippy::type_complexity)]
+    pub struct JoinHandle<T> {
+        fut:
+            Either<task::JoinHandle<T>, Pin<Box<dyn Future<Output = Result<T, Canceled>>>>>,
+    }
+
+    impl<T> Future for JoinHandle<T> {
+        type Output = Result<T, Canceled>;
+
+        fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+            match self.fut {
+                Either::Left(ref mut f) => match Pin::new(f).poll(cx) {
+                    Poll::Pending => Poll::Pending,
+                    Poll::Ready(res) => Poll::Ready(res.ok_or(Canceled)),
+                },
+                Either::Right(ref mut f) => Pin::new(f).poll(cx),
+            }
        }
    }
 }
@ -403,14 +464,22 @@ mod neon {
 #[cfg(feature = "tokio")]
 pub use self::tokio::*;

+#[cfg(feature = "async-std")]
+pub use self::asyncstd::*;
+
+#[cfg(feature = "glommio")]
+pub use self::glommio::*;
+
 #[cfg(feature = "compio")]
 pub use self::compio::*;

-#[cfg(feature = "neon")]
-pub use self::neon::*;
-
 #[allow(dead_code)]
-#[cfg(all(not(feature = "tokio"), not(feature = "compio"), not(feature = "neon")))]
+#[cfg(all(
+    not(feature = "tokio"),
+    not(feature = "async-std"),
+    not(feature = "compio"),
+    not(feature = "glommio")
+))]
 mod no_rt {
    use std::task::{Context, Poll};
    use std::{fmt, future::Future, marker::PhantomData, pin::Pin};
@ -469,5 +538,10 @@ mod no_rt {
    impl std::error::Error for JoinError {}
 }

-#[cfg(all(not(feature = "tokio"), not(feature = "compio"), not(feature = "neon")))]
+#[cfg(all(
+    not(feature = "tokio"),
+    not(feature = "async-std"),
+    not(feature = "compio"),
+    not(feature = "glommio")
+))]
 pub use self::no_rt::*;
--- a/ntex-rt/src/system.rs
+++ b/ntex-rt/src/system.rs
@ -1,31 +1,13 @@
-use std::collections::{HashMap, VecDeque};
 use std::sync::{atomic::AtomicUsize, atomic::Ordering, Arc};
-use std::time::{Duration, Instant};
 use std::{cell::RefCell, fmt, future::Future, pin::Pin, rc::Rc};

-use async_channel::{Receiver, Sender};
-use futures_timer::Delay;
+use async_channel::Sender;

-use super::arbiter::Arbiter;
+use super::arbiter::{Arbiter, SystemCommand};
 use super::builder::{Builder, SystemRunner};

 static SYSTEM_COUNT: AtomicUsize = AtomicUsize::new(0);

-thread_local!(
-    static ARBITERS: RefCell<Arbiters> = RefCell::new(Arbiters::default());
-    static PINGS: RefCell<HashMap<Id, VecDeque<PingRecord>>> =
-        RefCell::new(HashMap::default());
-);
-
-#[derive(Default)]
-struct Arbiters {
-    all: HashMap<Id, Arbiter>,
-    list: Vec<Arbiter>,
-}
-
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
-pub struct Id(pub(crate) usize);
-
 /// System is a runtime manager.
 #[derive(Clone, Debug)]
 pub struct System {
@ -51,17 +33,14 @@ impl System {
    /// Constructs new system and sets it as current
    pub(super) fn construct(
        sys: Sender<SystemCommand>,
-        mut arbiter: Arbiter,
+        arbiter: Arbiter,
        config: SystemConfig,
    ) -> Self {
-        let id = SYSTEM_COUNT.fetch_add(1, Ordering::SeqCst);
-        arbiter.sys_id = id;
-
        let sys = System {
-            id,
            sys,
            config,
            arbiter,
+            id: SYSTEM_COUNT.fetch_add(1, Ordering::SeqCst),
        };
        System::set_current(sys.clone());
        sys
@ -100,8 +79,8 @@ impl System {
    }

    /// System id
-    pub fn id(&self) -> Id {
-        Id(self.id)
+    pub fn id(&self) -> usize {
+        self.id
    }

    /// Stop the system
@ -125,34 +104,6 @@ impl System {
        &self.arbiter
    }

-    /// Retrieves a list of all arbiters in the system.
-    ///
-    /// This method should be called from the thread where the system has been initialized,
-    /// typically the "main" thread.
-    pub fn list_arbiters<F, R>(f: F) -> R
-    where
-        F: FnOnce(&[Arbiter]) -> R,
-    {
-        ARBITERS.with(|arbs| f(arbs.borrow().list.as_ref()))
-    }
-
-    /// Retrieves a list of last pings records for specified arbiter.
-    ///
-    /// This method should be called from the thread where the system has been initialized,
-    /// typically the "main" thread.
-    pub fn list_arbiter_pings<F, R>(id: Id, f: F) -> R
-    where
-        F: FnOnce(Option<&VecDeque<PingRecord>>) -> R,
-    {
-        PINGS.with(|pings| {
-            if let Some(recs) = pings.borrow().get(&id) {
-                f(Some(recs))
-            } else {
-                f(None)
-            }
-        })
-    }
-
    pub(super) fn sys(&self) -> &Sender<SystemCommand> {
        &self.sys
    }
@ -199,173 +150,3 @@ impl fmt::Debug for SystemConfig {
            .finish()
    }
 }
-
-#[derive(Debug)]
-pub(super) enum SystemCommand {
-    Exit(i32),
-    RegisterArbiter(Id, Arbiter),
-    UnregisterArbiter(Id),
-}
-
-pub(super) struct SystemSupport {
-    stop: Option<oneshot::Sender<i32>>,
-    commands: Receiver<SystemCommand>,
-    ping_interval: Duration,
-}
-
-impl SystemSupport {
-    pub(super) fn new(
-        stop: oneshot::Sender<i32>,
-        commands: Receiver<SystemCommand>,
-        ping_interval: usize,
-    ) -> Self {
-        Self {
-            commands,
-            stop: Some(stop),
-            ping_interval: Duration::from_millis(ping_interval as u64),
-        }
-    }
-
-    pub(super) async fn run(mut self) {
-        ARBITERS.with(move |arbs| {
-            let mut arbiters = arbs.borrow_mut();
-            arbiters.all.clear();
-            arbiters.list.clear();
-        });
-
-        loop {
-            match self.commands.recv().await {
-                Ok(SystemCommand::Exit(code)) => {
-                    log::debug!("Stopping system with {} code", code);
-
-                    // stop arbiters
-                    ARBITERS.with(move |arbs| {
-                        let mut arbiters = arbs.borrow_mut();
-                        for arb in arbiters.list.drain(..) {
-                            arb.stop();
-                        }
-                        arbiters.all.clear();
-                    });
-
-                    // stop event loop
-                    if let Some(stop) = self.stop.take() {
-                        let _ = stop.send(code);
-                    }
-                }
-                Ok(SystemCommand::RegisterArbiter(id, hnd)) => {
-                    crate::spawn(ping_arbiter(hnd.clone(), self.ping_interval));
-                    ARBITERS.with(move |arbs| {
-                        let mut arbiters = arbs.borrow_mut();
-                        arbiters.all.insert(id, hnd.clone());
-                        arbiters.list.push(hnd);
-                    });
-                }
-                Ok(SystemCommand::UnregisterArbiter(id)) => {
-                    ARBITERS.with(move |arbs| {
-                        let mut arbiters = arbs.borrow_mut();
-                        if let Some(hnd) = arbiters.all.remove(&id) {
-                            for (idx, arb) in arbiters.list.iter().enumerate() {
-                                if &hnd == arb {
-                                    arbiters.list.remove(idx);
-                                    break;
-                                }
-                            }
-                        }
-                    });
-                }
-                Err(_) => {
-                    log::debug!("System stopped");
-                    return;
-                }
-            }
-        }
-    }
-}
-
-#[derive(Copy, Clone, Debug)]
-pub struct PingRecord {
-    /// Ping start time
-    pub start: Instant,
-    /// Round-trip time, if value is not set then ping is in process
-    pub rtt: Option<Duration>,
-}
-
-async fn ping_arbiter(arb: Arbiter, interval: Duration) {
-    loop {
-        Delay::new(interval).await;
-
-        // check if arbiter is still active
-        let is_alive = ARBITERS.with(|arbs| arbs.borrow().all.contains_key(&arb.id()));
-
-        if !is_alive {
-            PINGS.with(|pings| pings.borrow_mut().remove(&arb.id()));
-            break;
-        }
-
-        // calc ttl
-        let start = Instant::now();
-        PINGS.with(|pings| {
-            let mut p = pings.borrow_mut();
-            let recs = p.entry(arb.id()).or_default();
-            recs.push_front(PingRecord { start, rtt: None });
-            recs.truncate(10);
-        });
-
-        let result = arb
-            .spawn_with(|| async {
-                yield_to().await;
-            })
-            .await;
-
-        if result.is_err() {
-            break;
-        }
-
-        PINGS.with(|pings| {
-            pings
-                .borrow_mut()
-                .get_mut(&arb.id())
-                .unwrap()
-                .front_mut()
-                .unwrap()
-                .rtt = Some(Instant::now() - start);
-        });
-    }
-}
-
-async fn yield_to() {
-    use std::task::{Context, Poll};
-
-    struct Yield {
-        completed: bool,
-    }
-
-    impl Future for Yield {
-        type Output = ();
-
-        fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
-            if self.completed {
-                return Poll::Ready(());
-            }
-            self.completed = true;
-            cx.waker().wake_by_ref();
-            Poll::Pending
-        }
-    }
-
-    Yield { completed: false }.await;
-}
-
-pub(super) trait FnExec: Send + 'static {
-    fn call_box(self: Box<Self>);
-}
-
-impl<F> FnExec for F
-where
-    F: FnOnce() + Send + 'static,
-{
-    #[allow(clippy::boxed_local)]
-    fn call_box(self: Box<Self>) {
-        (*self)()
-    }
-}
--- a/ntex-server/CHANGES.md
+++ b/ntex-server/CHANGES.md
@ -1,33 +1,5 @@
 # Changes

-## [2.7.3] - 2025-03-28
-
-* Better worker availability handling
-
-## [2.7.2] - 2025-03-27
-
-* Handle paused state
-
-## [2.7.1] - 2025-02-28
-
-* Fix set core affinity out of worker start #508
-
-## [2.7.0] - 2025-01-31
-
-* Cpu affinity support for workers
-
-## [2.6.2] - 2024-12-30
-
-* Fix error log
-
-## [2.6.1] - 2024-12-26
-
-* Tune shutdown logging
-
-## [2.6.0] - 2024-12-04
-
-* Use updated Service trait
-
 ## [2.5.0] - 2024-11-04

 * Use updated Service trait
--- a/ntex-server/Cargo.toml
+++ b/ntex-server/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "ntex-server"
-version = "2.7.4"
+version = "2.5.0"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "Server for ntex framework"
 keywords = ["network", "framework", "async", "futures"]
@ -18,17 +18,16 @@ path = "src/lib.rs"
 [dependencies]
 ntex-bytes = "0.1"
 ntex-net = "2"
-ntex-service = "3.4"
+ntex-service = "3.3"
 ntex-rt = "0.4"
-ntex-util = "2.8"
+ntex-util = "2.5"

-async-channel = { workspace = true }
-atomic-waker = { workspace = true }
-core_affinity = { workspace = true }
-oneshot = { workspace = true }
-polling = { workspace = true }
-log = { workspace = true }
-socket2 = { workspace = true }
+async-channel = "2"
+async-broadcast = "0.7"
+polling = "3.3"
+log = "0.4"
+socket2 = "0.5"
+oneshot = { version = "0.1", default-features = false, features = ["async"] }

 [dev-dependencies]
 ntex = "2"
--- a/ntex-server/src/manager.rs
+++ b/ntex-server/src/manager.rs
@ -2,7 +2,6 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use std::{cell::Cell, cell::RefCell, collections::VecDeque, rc::Rc, sync::Arc};

 use async_channel::{unbounded, Receiver, Sender};
-use core_affinity::CoreId;
 use ntex_rt::System;
 use ntex_util::future::join_all;
 use ntex_util::time::{sleep, timeout, Millis};
@ -70,16 +69,9 @@ impl<F: ServerConfiguration> ServerManager<F> {
        // handle cmd
        let _ = ntex_rt::spawn(handle_cmd(mgr.clone(), rx));

-        // Retrieve the IDs of all active CPU cores.
-        let mut cores = if cfg.affinity {
-            core_affinity::get_core_ids().unwrap_or_default()
-        } else {
-            Vec::new()
-        };
-
        // start workers
        for _ in 0..mgr.0.cfg.num {
-            start_worker(mgr.clone(), cores.pop());
+            start_worker(mgr.clone());
        }

        let srv = Server::new(tx, shared);
@ -136,10 +128,10 @@ impl<F: ServerConfiguration> ServerManager<F> {
    }
 }

-fn start_worker<F: ServerConfiguration>(mgr: ServerManager<F>, cid: Option<CoreId>) {
+fn start_worker<F: ServerConfiguration>(mgr: ServerManager<F>) {
    let _ = ntex_rt::spawn(async move {
        let id = mgr.next_id();
-        let mut wrk = Worker::start(id, mgr.factory(), cid);
+        let mut wrk = Worker::start(id, mgr.factory());

        loop {
            match wrk.status() {
@ -149,7 +141,7 @@ fn start_worker<F: ServerConfiguration>(mgr: ServerManager<F>, cid: Option<CoreI
                    mgr.unavailable(wrk);
                    sleep(RESTART_DELAY).await;
                    if !mgr.stopping() {
-                        wrk = Worker::start(id, mgr.factory(), cid);
+                        wrk = Worker::start(id, mgr.factory());
                    } else {
                        return;
                    }
@ -180,7 +172,7 @@ impl<F: ServerConfiguration> HandleCmdState<F> {
    fn process(&mut self, mut item: F::Item) {
        loop {
            if !self.workers.is_empty() {
-                if self.next >= self.workers.len() {
+                if self.next > self.workers.len() {
                    self.next = self.workers.len() - 1;
                }
                match self.workers[self.next].send(item) {
@ -211,9 +203,10 @@ impl<F: ServerConfiguration> HandleCmdState<F> {
        match upd {
            Update::Available(worker) => {
                self.workers.push(worker);
-                self.workers.sort();
                if self.workers.len() == 1 {
                    self.mgr.resume();
+                } else {
+                    self.workers.sort();
                }
            }
            Update::Unavailable(worker) => {
@ -232,9 +225,6 @@ impl<F: ServerConfiguration> HandleCmdState<F> {
                if let Err(item) = self.workers[0].send(item) {
                    self.backlog.push_back(item);
                    self.workers.remove(0);
-                    if self.workers.is_empty() {
-                        self.mgr.pause();
-                    }
                    break;
                }
            }
@ -272,10 +262,10 @@ impl<F: ServerConfiguration> HandleCmdState<F> {
        for tx in notify {
            let _ = tx.send(());
        }
-        sleep(STOP_DELAY).await;

        // stop system if server was spawned
        if self.mgr.0.cfg.stop_runtime {
+            sleep(STOP_DELAY).await;
            System::current().stop();
        }
    }
--- a/ntex-server/src/net/accept.rs
+++ b/ntex-server/src/net/accept.rs
@ -92,14 +92,12 @@ impl AcceptLoop {

    /// Start accept loop
    pub fn start(mut self, socks: Vec<(Token, Listener)>, srv: Server) {
-        let (tx, rx_start) = oneshot::channel();
        let (rx, poll) = self
            .inner
            .take()
            .expect("AcceptLoop cannot be used multiple times");

        Accept::start(
-            tx,
            rx,
            poll,
            socks,
@ -107,8 +105,6 @@ impl AcceptLoop {
            self.notify.clone(),
            self.status_handler.take(),
        );
-
-        let _ = rx_start.recv();
    }
 }

@ -125,7 +121,6 @@ impl fmt::Debug for AcceptLoop {
 struct Accept {
    poller: Arc<Poller>,
    rx: mpsc::Receiver<AcceptorCommand>,
-    tx: Option<oneshot::Sender<()>>,
    sockets: Vec<ServerSocketInfo>,
    srv: Server,
    notify: AcceptNotify,
@ -136,7 +131,6 @@ struct Accept {

 impl Accept {
    fn start(
-        tx: oneshot::Sender<()>,
        rx: mpsc::Receiver<AcceptorCommand>,
        poller: Arc<Poller>,
        socks: Vec<(Token, Listener)>,
@ -151,12 +145,11 @@ impl Accept {
            .name("ntex-server accept loop".to_owned())
            .spawn(move || {
                System::set_current(sys);
-                Accept::new(tx, rx, poller, socks, srv, notify, status_handler).poll()
+                Accept::new(rx, poller, socks, srv, notify, status_handler).poll()
            });
    }

    fn new(
-        tx: oneshot::Sender<()>,
        rx: mpsc::Receiver<AcceptorCommand>,
        poller: Arc<Poller>,
        socks: Vec<(Token, Listener)>,
@ -182,7 +175,6 @@ impl Accept {
            notify,
            srv,
            status_handler,
-            tx: Some(tx),
            backpressure: true,
            backlog: VecDeque::new(),
        }
@ -200,23 +192,19 @@ impl Accept {
        // Create storage for events
        let mut events = Events::with_capacity(NonZeroUsize::new(512).unwrap());

-        let mut timeout = Some(Duration::ZERO);
        loop {
-            if let Err(e) = self.poller.wait(&mut events, timeout) {
-                if e.kind() != io::ErrorKind::Interrupted {
+            if let Err(e) = self.poller.wait(&mut events, None) {
+                if e.kind() == io::ErrorKind::Interrupted {
+                    continue;
+                } else {
                    panic!("Cannot wait for events in poller: {}", e)
                }
-            } else if timeout.is_some() {
-                timeout = None;
-                let _ = self.tx.take().unwrap().send(());
            }

-            for idx in 0..self.sockets.len() {
-                if self.sockets[idx].registered.get() {
-                    let readd = self.accept(idx);
-                    if readd {
-                        self.add_source(idx);
-                    }
+            for event in events.iter() {
+                let readd = self.accept(event.key);
+                if readd {
+                    self.add_source(event.key);
                }
            }

@ -227,13 +215,13 @@ impl Accept {
                    for info in self.sockets.drain(..) {
                        info.sock.remove_source()
                    }
-                    log::info!("Accept loop has been stopped");

                    if let Some(rx) = rx {
                        thread::sleep(EXIT_TIMEOUT);
                        let _ = rx.send(());
                    }

+                    log::trace!("Accept loop has been stopped");
                    break;
                }
            }
@ -307,25 +295,25 @@ impl Accept {
                Ok(cmd) => match cmd {
                    AcceptorCommand::Stop(rx) => {
                        if !self.backpressure {
-                            log::info!("Stopping accept loop");
+                            log::trace!("Stopping accept loop");
                            self.backpressure(true);
                        }
                        break Either::Right(Some(rx));
                    }
                    AcceptorCommand::Terminate => {
-                        log::info!("Stopping accept loop");
+                        log::trace!("Stopping accept loop");
                        self.backpressure(true);
                        break Either::Right(None);
                    }
                    AcceptorCommand::Pause => {
                        if !self.backpressure {
-                            log::info!("Pausing accept loop");
+                            log::trace!("Pausing accept loop");
                            self.backpressure(true);
                        }
                    }
                    AcceptorCommand::Resume => {
                        if self.backpressure {
-                            log::info!("Resuming accept loop");
+                            log::trace!("Resuming accept loop");
                            self.backpressure(false);
                        }
                    }
@ -337,11 +325,10 @@ impl Accept {
                    break match err {
                        mpsc::TryRecvError::Empty => Either::Left(()),
                        mpsc::TryRecvError::Disconnected => {
-                            log::error!("Dropping accept loop");
                            self.backpressure(true);
                            Either::Right(None)
                        }
-                    };
+                    }
                }
            }
        }
--- a/ntex-server/src/net/builder.rs
+++ b/ntex-server/src/net/builder.rs
@ -110,14 +110,6 @@ impl ServerBuilder {
        self
    }

-    /// Enable cpu affinity
-    ///
-    /// By default affinity is disabled.
-    pub fn enable_affinity(mut self) -> Self {
-        self.pool = self.pool.enable_affinity();
-        self
-    }
-
    /// Timeout for graceful workers shutdown.
    ///
    /// After receiving a stop signal, workers have this much time to finish
@ -368,7 +360,7 @@ pub fn bind_addr<S: net::ToSocketAddrs>(
            Err(e)
        } else {
            Err(io::Error::new(
-                io::ErrorKind::InvalidInput,
+                io::ErrorKind::Other,
                "Cannot bind to address.",
            ))
        }
--- a/ntex-server/src/net/service.rs
+++ b/ntex-server/src/net/service.rs
@ -1,4 +1,4 @@
-use std::{fmt, task::Context};
+use std::{fmt, future::poll_fn, future::Future, pin::Pin, task::Poll};

 use ntex_bytes::{Pool, PoolRef};
 use ntex_net::Io;
@ -170,11 +170,27 @@ impl Service<Connection> for StreamServiceImpl {
    }

    #[inline]
-    fn poll(&self, cx: &mut Context<'_>) -> Result<(), Self::Error> {
-        for svc in &self.services {
-            svc.poll(cx)?;
+    async fn not_ready(&self) {
+        if self.conns.is_available() {
+            let mut futs: Vec<_> = self
+                .services
+                .iter()
+                .map(|s| Box::pin(s.not_ready()))
+                .collect();
+
+            ntex_util::future::select(
+                self.conns.unavailable(),
+                poll_fn(move |cx| {
+                    for f in &mut futs {
+                        if Pin::new(f).poll(cx).is_ready() {
+                            return Poll::Ready(());
+                        }
+                    }
+                    Poll::Pending
+                }),
+            )
+            .await;
        }
-        Ok(())
    }

    async fn shutdown(&self) {
--- a/ntex-server/src/net/test.rs
+++ b/ntex-server/src/net/test.rs
@ -59,13 +59,8 @@ where
                .workers(1)
                .disable_signals()
                .run();
-
-            ntex_rt::spawn(async move {
-                ntex_util::time::sleep(ntex_util::time::Millis(75)).await;
-                tx.send((system, local_addr, server))
-                    .expect("Failed to send Server to TestServer");
-            });
-
+            tx.send((system, local_addr, server))
+                .expect("Failed to send Server to TestServer");
            Ok(())
        })
    });
--- a/ntex-server/src/pool.rs
+++ b/ntex-server/src/pool.rs
@ -11,7 +11,6 @@ pub struct WorkerPool {
    pub(crate) no_signals: bool,
    pub(crate) stop_runtime: bool,
    pub(crate) shutdown_timeout: Millis,
-    pub(crate) affinity: bool,
 }

 impl Default for WorkerPool {
@ -23,18 +22,12 @@ impl Default for WorkerPool {
 impl WorkerPool {
    /// Create new Server builder instance
    pub fn new() -> Self {
-        let num = core_affinity::get_core_ids()
-            .map(|v| v.len())
-            .unwrap_or_else(|| {
-                std::thread::available_parallelism().map_or(2, std::num::NonZeroUsize::get)
-            });
-
        WorkerPool {
-            num,
+            num: std::thread::available_parallelism()
+                .map_or(2, std::num::NonZeroUsize::get),
            no_signals: false,
            stop_runtime: false,
            shutdown_timeout: DEFAULT_SHUTDOWN_TIMEOUT,
-            affinity: false,
        }
    }

@ -75,14 +68,6 @@ impl WorkerPool {
        self
    }

-    /// Enable core affinity
-    ///
-    /// By default affinity is disabled.
-    pub fn enable_affinity(mut self) -> Self {
-        self.affinity = true;
-        self
-    }
-
    /// Starts processing incoming items and return server controller.
    pub fn run<F: ServerConfiguration>(self, factory: F) -> Server<F::Item> {
        crate::manager::ServerManager::start(self, factory)
--- a/ntex-server/src/wrk.rs
+++ b/ntex-server/src/wrk.rs
@ -2,9 +2,8 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use std::task::{ready, Context, Poll};
 use std::{cmp, future::poll_fn, future::Future, hash, pin::Pin, sync::Arc};

+use async_broadcast::{self as bus, broadcast};
 use async_channel::{unbounded, Receiver, Sender};
-use atomic_waker::AtomicWaker;
-use core_affinity::CoreId;

 use ntex_rt::{spawn, Arbiter};
 use ntex_service::{Pipeline, PipelineBinding, Service, ServiceFactory};
@ -78,7 +77,7 @@ pub struct WorkerStop(oneshot::Receiver<bool>);

 impl<T> Worker<T> {
    /// Start worker.
-    pub fn start<F>(id: WorkerId, cfg: F, cid: Option<CoreId>) -> Worker<T>
+    pub fn start<F>(id: WorkerId, cfg: F) -> Worker<T>
    where
        T: Send + 'static,
        F: ServerConfiguration<Item = T>,
@ -88,21 +87,15 @@ impl<T> Worker<T> {
        let (avail, avail_tx) = WorkerAvailability::create();

        Arbiter::default().exec_fn(move || {
-            if let Some(cid) = cid {
-                if core_affinity::set_for_current(cid) {
-                    log::info!("Set affinity to {:?} for worker {:?}", cid, id);
-                }
-            }
-
            let _ = spawn(async move {
                log::info!("Starting worker {:?}", id);

                log::debug!("Creating server instance in {:?}", id);
                let factory = cfg.create().await;
+                log::debug!("Server instance has been created in {:?}", id);

                match create(id, rx1, rx2, factory, avail_tx).await {
                    Ok((svc, wrk)) => {
-                        log::debug!("Server instance has been created in {:?}", id);
                        run_worker(svc, wrk).await;
                    }
                    Err(e) => {
@ -151,8 +144,10 @@ impl<T> Worker<T> {
        if self.failed.load(Ordering::Acquire) {
            WorkerStatus::Failed
        } else {
-            self.avail.wait_for_update().await;
-            if self.avail.failed() {
+            // cleanup updates
+            while self.avail.notify.try_recv().is_ok() {}
+
+            if self.avail.notify.recv_direct().await.is_err() {
                self.failed.store(true, Ordering::Release);
            }
            self.status()
@ -194,85 +189,52 @@ impl Future for WorkerStop {

 #[derive(Debug, Clone)]
 struct WorkerAvailability {
-    inner: Arc<Inner>,
+    notify: bus::Receiver<()>,
+    available: Arc<AtomicBool>,
 }

 #[derive(Debug, Clone)]
 struct WorkerAvailabilityTx {
-    inner: Arc<Inner>,
-}
-
-#[derive(Debug)]
-struct Inner {
-    waker: AtomicWaker,
-    updated: AtomicBool,
-    available: AtomicBool,
-    failed: AtomicBool,
+    notify: bus::Sender<()>,
+    available: Arc<AtomicBool>,
 }

 impl WorkerAvailability {
    fn create() -> (Self, WorkerAvailabilityTx) {
-        let inner = Arc::new(Inner {
-            waker: AtomicWaker::new(),
-            updated: AtomicBool::new(false),
-            available: AtomicBool::new(false),
-            failed: AtomicBool::new(false),
-        });
+        let (mut tx, rx) = broadcast(16);
+        tx.set_overflow(true);

        let avail = WorkerAvailability {
-            inner: inner.clone(),
+            notify: rx,
+            available: Arc::new(AtomicBool::new(false)),
+        };
+        let avail_tx = WorkerAvailabilityTx {
+            notify: tx,
+            available: avail.available.clone(),
        };
-        let avail_tx = WorkerAvailabilityTx { inner };
        (avail, avail_tx)
    }

-    fn failed(&self) -> bool {
-        self.inner.failed.load(Ordering::Acquire)
-    }
-
    fn available(&self) -> bool {
-        self.inner.available.load(Ordering::Acquire)
-    }
-
-    async fn wait_for_update(&self) {
-        poll_fn(|cx| {
-            if self.inner.updated.load(Ordering::Acquire) {
-                self.inner.updated.store(false, Ordering::Release);
-                Poll::Ready(())
-            } else {
-                self.inner.waker.register(cx.waker());
-                Poll::Pending
-            }
-        })
-        .await;
+        self.available.load(Ordering::Acquire)
    }
 }

 impl WorkerAvailabilityTx {
    fn set(&self, val: bool) {
-        let old = self.inner.available.swap(val, Ordering::Release);
-        if old != val {
-            self.inner.updated.store(true, Ordering::Release);
-            self.inner.waker.wake();
+        let old = self.available.swap(val, Ordering::Release);
+        if !old && val {
+            let _ = self.notify.try_broadcast(());
        }
    }
 }

-impl Drop for WorkerAvailabilityTx {
-    fn drop(&mut self) {
-        self.inner.failed.store(true, Ordering::Release);
-        self.inner.updated.store(true, Ordering::Release);
-        self.inner.available.store(false, Ordering::Release);
-        self.inner.waker.wake();
-    }
-}
-
 /// Service worker
 ///
 /// Worker accepts message via unbounded channel and starts processing.
 struct WorkerSt<T, F: ServiceFactory<T>> {
    id: WorkerId,
-    rx: Receiver<T>,
+    rx: Pin<Box<dyn Stream<Item = T>>>,
    stop: Pin<Box<dyn Stream<Item = Shutdown>>>,
    factory: F,
    availability: WorkerAvailabilityTx,
@ -284,43 +246,25 @@ where
    F: ServiceFactory<T> + 'static,
 {
    loop {
-        let mut recv = std::pin::pin!(wrk.rx.recv());
        let fut = poll_fn(|cx| {
-            match svc.poll_ready(cx) {
-                Poll::Ready(Ok(())) => {
-                    wrk.availability.set(true);
-                }
-                Poll::Ready(Err(err)) => {
-                    wrk.availability.set(false);
-                    return Poll::Ready(Err(err));
-                }
-                Poll::Pending => {
-                    wrk.availability.set(false);
-                    return Poll::Pending;
-                }
-            }
+            ready!(svc.poll_ready(cx)?);

-            match ready!(recv.as_mut().poll(cx)) {
-                Ok(item) => {
-                    let fut = svc.call(item);
-                    let _ = spawn(async move {
-                        let _ = fut.await;
-                    });
-                    Poll::Ready(Ok::<_, F::Error>(true))
-                }
-                Err(_) => {
-                    log::error!("Server is gone");
-                    Poll::Ready(Ok(false))
-                }
+            if let Some(item) = ready!(Pin::new(&mut wrk.rx).poll_next(cx)) {
+                let fut = svc.call(item);
+                let _ = spawn(async move {
+                    let _ = fut.await;
+                });
            }
+            Poll::Ready(Ok::<(), F::Error>(()))
        });

        match select(fut, stream_recv(&mut wrk.stop)).await {
-            Either::Left(Ok(true)) => continue,
+            Either::Left(Ok(())) => continue,
            Either::Left(Err(_)) => {
                let _ = ntex_rt::spawn(async move {
                    svc.shutdown().await;
                });
+                wrk.availability.set(false);
            }
            Either::Right(Some(Shutdown { timeout, result })) => {
                wrk.availability.set(false);
@ -334,8 +278,7 @@ where
                stop_svc(wrk.id, svc, timeout, Some(result)).await;
                return;
            }
-            Either::Left(Ok(false)) | Either::Right(None) => {
-                wrk.availability.set(false);
+            Either::Right(None) => {
                stop_svc(wrk.id, svc, STOP_TIMEOUT, None).await;
                return;
            }
@ -345,6 +288,7 @@ where
        loop {
            match select(wrk.factory.create(()), stream_recv(&mut wrk.stop)).await {
                Either::Left(Ok(service)) => {
+                    wrk.availability.set(true);
                    svc = Pipeline::new(service).bind();
                    break;
                }
@ -385,6 +329,8 @@ where
 {
    availability.set(false);
    let factory = factory?;
+
+    let rx = Box::pin(rx);
    let mut stop = Box::pin(stop);

    let svc = match select(factory.create(()), stream_recv(&mut stop)).await {
@ -403,9 +349,9 @@ where
        svc,
        WorkerSt {
            id,
-            rx,
            factory,
            availability,
+            rx: Box::pin(rx),
            stop: Box::pin(stop),
        },
    ))
--- a/ntex-service/CHANGES.md
+++ b/ntex-service/CHANGES.md
@ -1,13 +1,5 @@
 # Changes

-## [3.4.0] - 2024-12-04
-
-* Added Service::poll() method
-
-## [3.3.3] - 2024-11-10
-
-* Add Pipeline::is_shutdown() helper
-
 ## [3.3.2] - 2024-11-10

 * Fix un-needed wakeups for unready future
--- a/ntex-service/Cargo.toml
+++ b/ntex-service/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "ntex-service"
-version = "3.4.0"
+version = "3.3.2"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "ntex service"
 keywords = ["network", "framework", "async", "futures"]
--- a/ntex-service/src/and_then.rs
+++ b/ntex-service/src/and_then.rs
@ -31,9 +31,8 @@ where
    }

    #[inline]
-    fn poll(&self, cx: &mut std::task::Context<'_>) -> Result<(), Self::Error> {
-        self.svc1.poll(cx)?;
-        self.svc2.poll(cx)
+    async fn not_ready(&self) {
+        util::select(self.svc1.not_ready(), self.svc2.not_ready()).await
    }

    #[inline]
@ -89,8 +88,8 @@ where

 #[cfg(test)]
 mod tests {
-    use ntex_util::future::lazy;
-    use std::{cell::Cell, rc::Rc, task::Context};
+    use ntex_util::time;
+    use std::{cell::Cell, rc::Rc};

    use crate::{chain, chain_factory, fn_factory, Service, ServiceCtx};

@ -106,9 +105,9 @@ mod tests {
            Ok(())
        }

-        fn poll(&self, _: &mut Context<'_>) -> Result<(), Self::Error> {
+        async fn not_ready(&self) {
            self.0.set(self.0.get() + 1);
-            Ok(())
+            std::future::pending().await
        }

        async fn call(
@ -136,9 +135,9 @@ mod tests {
            Ok(())
        }

-        fn poll(&self, _: &mut Context<'_>) -> Result<(), Self::Error> {
+        async fn not_ready(&self) {
            self.0.set(self.0.get() + 1);
-            Ok(())
+            std::future::pending().await
        }

        async fn call(
@ -166,7 +165,11 @@ mod tests {
        assert_eq!(res, Ok(()));
        assert_eq!(cnt.get(), 2);

-        lazy(|cx| srv.clone().poll(cx)).await.unwrap();
+        let srv2 = srv.clone();
+        ntex::rt::spawn(async move {
+            let _ = srv2.not_ready().await;
+        });
+        time::sleep(time::Millis(25)).await;
        assert_eq!(cnt.get(), 4);

        srv.shutdown().await;
--- a/ntex-service/src/apply.rs
+++ b/ntex-service/src/apply.rs
@ -113,7 +113,7 @@ where
        (self.f)(req, self.service.clone()).await
    }

-    crate::forward_poll!(service);
+    crate::forward_notready!(service);
    crate::forward_shutdown!(service);
 }

@ -205,8 +205,7 @@ where

 #[cfg(test)]
 mod tests {
-    use ntex_util::future::lazy;
-    use std::{cell::Cell, rc::Rc, task::Context};
+    use std::{cell::Cell, rc::Rc};

    use super::*;
    use crate::{chain, chain_factory, fn_factory};
@ -222,9 +221,8 @@ mod tests {
            Ok(())
        }

-        fn poll(&self, _: &mut Context<'_>) -> Result<(), Self::Error> {
+        async fn not_ready(&self) {
            self.0.set(self.0.get() + 1);
-            Ok(())
        }

        async fn shutdown(&self) {
@ -255,7 +253,7 @@ mod tests {

        assert_eq!(srv.ready().await, Ok::<_, Err>(()));

-        lazy(|cx| srv.poll(cx)).await.unwrap();
+        srv.not_ready().await;
        assert_eq!(cnt_sht.get(), 1);

        srv.shutdown().await;
--- a/ntex-service/src/boxed.rs
+++ b/ntex-service/src/boxed.rs
@ -1,4 +1,4 @@
-use std::{fmt, future::Future, pin::Pin, task::Context};
+use std::{fmt, future::Future, pin::Pin};

 use crate::ctx::{ServiceCtx, WaitersRef};

@ -54,6 +54,8 @@ trait ServiceObj<Req> {
        waiters: &'a WaitersRef,
    ) -> BoxFuture<'a, (), Self::Error>;

+    fn not_ready<'a>(&'a self) -> Pin<Box<dyn Future<Output = ()> + 'a>>;
+
    fn call<'a>(
        &'a self,
        req: Req,
@ -62,8 +64,6 @@ trait ServiceObj<Req> {
    ) -> BoxFuture<'a, Self::Response, Self::Error>;

    fn shutdown<'a>(&'a self) -> Pin<Box<dyn Future<Output = ()> + 'a>>;
-
-    fn poll(&self, cx: &mut Context<'_>) -> Result<(), Self::Error>;
 }

 impl<S, Req> ServiceObj<Req> for S
@ -83,6 +83,11 @@ where
        Box::pin(async move { ServiceCtx::<'a, S>::new(idx, waiters).ready(self).await })
    }

+    #[inline]
+    fn not_ready<'a>(&'a self) -> Pin<Box<dyn Future<Output = ()> + 'a>> {
+        Box::pin(crate::Service::not_ready(self))
+    }
+
    #[inline]
    fn shutdown<'a>(&'a self) -> Pin<Box<dyn Future<Output = ()> + 'a>> {
        Box::pin(crate::Service::shutdown(self))
@ -101,11 +106,6 @@ where
                .await
        })
    }
-
-    #[inline]
-    fn poll(&self, cx: &mut Context<'_>) -> Result<(), Self::Error> {
-        crate::Service::poll(self, cx)
-    }
 }

 trait ServiceFactoryObj<Req, Cfg> {
@ -158,6 +158,11 @@ where
        self.0.ready(idx, waiters).await
    }

+    #[inline]
+    async fn not_ready(&self) {
+        self.0.not_ready().await
+    }
+
    #[inline]
    async fn shutdown(&self) {
        self.0.shutdown().await
@ -168,11 +173,6 @@ where
        let (idx, waiters) = ctx.inner();
        self.0.call(req, idx, waiters).await
    }
-
-    #[inline]
-    fn poll(&self, cx: &mut Context<'_>) -> Result<(), Self::Error> {
-        self.0.poll(cx)
-    }
 }

 impl<C, Req, Res, Err, InitErr> crate::ServiceFactory<Req, C>
--- a/ntex-service/src/chain.rs
+++ b/ntex-service/src/chain.rs
@ -171,7 +171,6 @@ impl<Svc: Service<Req>, Req> Service<Req> for ServiceChain<Svc, Req> {
    type Response = Svc::Response;
    type Error = Svc::Error;

-    crate::forward_poll!(service);
    crate::forward_ready!(service);
    crate::forward_shutdown!(service);

--- a/ntex-service/src/ctx.rs
+++ b/ntex-service/src/ctx.rs
@ -12,7 +12,6 @@ pub struct ServiceCtx<'a, S: ?Sized> {
 #[derive(Debug)]
 pub(crate) struct WaitersRef {
    cur: cell::Cell<u32>,
-    shutdown: cell::Cell<bool>,
    wakers: cell::UnsafeCell<Vec<u32>>,
    indexes: cell::UnsafeCell<slab::Slab<Option<Waker>>>,
 }
@ -20,12 +19,10 @@ pub(crate) struct WaitersRef {
 impl WaitersRef {
    pub(crate) fn new() -> (u32, Self) {
        let mut waiters = slab::Slab::new();
-
        (
            waiters.insert(Default::default()) as u32,
            WaitersRef {
                cur: cell::Cell::new(u32::MAX),
-                shutdown: cell::Cell::new(false),
                indexes: cell::UnsafeCell::new(waiters),
                wakers: cell::UnsafeCell::new(Vec::default()),
            },
@ -93,14 +90,6 @@ impl WaitersRef {
            false
        }
    }
-
-    pub(crate) fn shutdown(&self) {
-        self.shutdown.set(true);
-    }
-
-    pub(crate) fn is_shutdown(&self) -> bool {
-        self.shutdown.get()
-    }
 }

 impl<'a, S> ServiceCtx<'a, S> {
--- a/ntex-service/src/lib.rs
+++ b/ntex-service/src/lib.rs
@ -6,7 +6,7 @@
    unreachable_pub,
    missing_debug_implementations
 )]
-use std::{rc::Rc, task::Context};
+use std::rc::Rc;

 mod and_then;
 mod apply;
@ -118,8 +118,7 @@ pub trait Service<Req> {
        Ok(())
    }

-    #[deprecated]
-    #[doc(hidden)]
+    #[inline]
    /// Returns when the service is not able to process requests.
    ///
    /// Unlike the "ready()" method, the "not_ready()" method returns
@ -137,15 +136,6 @@ pub trait Service<Req> {
    /// Returns when the service is properly shutdowns.
    async fn shutdown(&self) {}

-    #[inline]
-    /// Polls service from the current task.
-    ///
-    /// Service may require to execute asynchronous computation or
-    /// maintain asynchronous state.
-    fn poll(&self, cx: &mut Context<'_>) -> Result<(), Self::Error> {
-        Ok(())
-    }
-
    #[inline]
    /// Map this service's output to a different type, returning a new service of the resulting type.
    ///
@ -256,7 +246,7 @@ pub trait ServiceFactory<Req, Cfg = ()> {
    }
 }

-impl<S, Req> Service<Req> for &S
+impl<'a, S, Req> Service<Req> for &'a S
 where
    S: Service<Req>,
 {
@ -269,8 +259,8 @@ where
    }

    #[inline]
-    fn poll(&self, cx: &mut Context<'_>) -> Result<(), S::Error> {
-        (**self).poll(cx)
+    async fn not_ready(&self) {
+        (**self).not_ready().await
    }

    #[inline]
@ -300,6 +290,11 @@ where
        ctx.ready(&**self).await
    }

+    #[inline]
+    async fn not_ready(&self) {
+        (**self).not_ready().await
+    }
+
    #[inline]
    async fn shutdown(&self) {
        (**self).shutdown().await
@ -313,11 +308,6 @@ where
    ) -> Result<Self::Response, Self::Error> {
        ctx.call_nowait(&**self, request).await
    }
-
-    #[inline]
-    fn poll(&self, cx: &mut Context<'_>) -> Result<(), S::Error> {
-        (**self).poll(cx)
-    }
 }

 impl<S, Req, Cfg> ServiceFactory<Req, Cfg> for Rc<S>
--- a/ntex-service/src/macros.rs
+++ b/ntex-service/src/macros.rs
@ -11,6 +11,11 @@ macro_rules! forward_ready {
                .await
                .map_err(::core::convert::Into::into)
        }
+
+        #[inline]
+        async fn not_ready(&self) {
+            self.$field.not_ready().await
+        }
    };
    ($field:ident, $err:expr) => {
        #[inline]
@ -20,28 +25,21 @@ macro_rules! forward_ready {
        ) -> Result<(), Self::Error> {
            ctx.ready(&self.$field).await.map_err($err)
        }
+
+        #[inline]
+        async fn not_ready(&self) {
+            self.$field.not_ready().await
+        }
    };
 }

 /// An implementation of [`not_ready`] that forwards not_ready call to a field.
 #[macro_export]
 macro_rules! forward_notready {
-    ($field:ident) => {};
-}
-
-/// An implementation of [`poll`] that forwards poll call to a field.
-#[macro_export]
-macro_rules! forward_poll {
    ($field:ident) => {
        #[inline]
-        fn poll(&self, cx: &mut std::task::Context<'_>) -> Result<(), Self::Error> {
-            self.$field.poll(cx).map_err(From::from)
-        }
-    };
-    ($field:ident, $err:expr) => {
-        #[inline]
-        fn poll(&self, cx: &mut std::task::Context<'_>) -> Result<(), Self::Error> {
-            self.$field.poll(cx).map_err($err)
+        async fn not_ready(&self) {
+            self.$field.not_ready().await
        }
    };
 }
--- a/ntex-service/src/map.rs
+++ b/ntex-service/src/map.rs
@ -62,7 +62,6 @@ where
    type Error = A::Error;

    crate::forward_ready!(service);
-    crate::forward_poll!(service);
    crate::forward_shutdown!(service);

    #[inline]
--- a/ntex-service/src/map_err.rs
+++ b/ntex-service/src/map_err.rs
@ -1,4 +1,4 @@
-use std::{fmt, marker::PhantomData, task::Context};
+use std::{fmt, marker::PhantomData};

 use super::{Service, ServiceCtx, ServiceFactory};

@ -67,11 +67,6 @@ where
        ctx.ready(&self.service).await.map_err(&self.f)
    }

-    #[inline]
-    fn poll(&self, cx: &mut Context<'_>) -> Result<(), Self::Error> {
-        self.service.poll(cx).map_err(&self.f)
-    }
-
    #[inline]
    async fn call(
        &self,
@ -82,6 +77,7 @@ where
    }

    crate::forward_shutdown!(service);
+    crate::forward_notready!(service);
 }

 /// Factory for the `map_err` combinator, changing the type of a new
--- a/ntex-service/src/pipeline.rs
+++ b/ntex-service/src/pipeline.rs
@ -1,4 +1,4 @@
-use std::{cell, fmt, future::Future, marker, pin::Pin, rc::Rc, task::Context, task::Poll};
+use std::{cell, fmt, future::Future, pin::Pin, rc::Rc, task::Context, task::Poll};

 use crate::{ctx::WaitersRef, Service, ServiceCtx};

@ -50,14 +50,13 @@ impl<S> Pipeline<S> {
            .await
    }

-    #[doc(hidden)]
-    #[deprecated]
+    #[inline]
    /// Returns when the pipeline is not able to process requests.
    pub async fn not_ready<R>(&self)
    where
        S: Service<R>,
    {
-        std::future::pending().await
+        self.state.svc.not_ready().await
    }

    #[inline]
@ -111,12 +110,6 @@ impl<S> Pipeline<S> {
        }
    }

-    #[inline]
-    /// Check if shutdown is initiated.
-    pub fn is_shutdown(&self) -> bool {
-        self.state.waiters.is_shutdown()
-    }
-
    #[inline]
    /// Shutdown enclosed service.
    pub async fn shutdown<R>(&self)
@ -126,14 +119,6 @@ impl<S> Pipeline<S> {
        self.state.svc.shutdown().await
    }

-    #[inline]
-    pub fn poll<R>(&self, cx: &mut Context<'_>) -> Result<(), S::Error>
-    where
-        S: Service<R>,
-    {
-        self.state.svc.poll(cx)
-    }
-
    #[inline]
    /// Get current pipeline.
    pub fn bind<R>(self) -> PipelineBinding<S, R>
@ -184,6 +169,7 @@ where
 {
    pl: Pipeline<S>,
    st: cell::UnsafeCell<State<S::Error>>,
+    not_ready: cell::UnsafeCell<StateNotReady>,
 }

 enum State<E> {
@ -192,6 +178,11 @@ enum State<E> {
    Shutdown(Pin<Box<dyn Future<Output = ()> + 'static>>),
 }

+enum StateNotReady {
+    New,
+    Readiness(Pin<Box<dyn Future<Output = ()>>>),
+}
+
 impl<S, R> PipelineBinding<S, R>
 where
    S: Service<R> + 'static,
@ -201,6 +192,7 @@ where
        PipelineBinding {
            pl,
            st: cell::UnsafeCell::new(State::New),
+            not_ready: cell::UnsafeCell::new(StateNotReady::New),
        }
    }

@ -210,17 +202,6 @@ where
        &self.pl.state.svc
    }

-    #[inline]
-    /// Get pipeline
-    pub fn pipeline(&self) -> Pipeline<S> {
-        self.pl.clone()
-    }
-
-    #[inline]
-    pub fn poll(&self, cx: &mut Context<'_>) -> Result<(), S::Error> {
-        self.pl.poll(cx)
-    }
-
    #[inline]
    /// Returns `Ready` when the pipeline is able to process requests.
    ///
@ -237,7 +218,6 @@ where
                let fut = Box::pin(CheckReadiness {
                    fut: None,
                    f: ready,
-                    _t: marker::PhantomData,
                    pl,
                });
                *st = State::Readiness(fut);
@ -248,12 +228,27 @@ where
        }
    }

-    #[doc(hidden)]
-    #[deprecated]
    #[inline]
    /// Returns when the pipeline is not able to process requests.
-    pub fn poll_not_ready(&self, _: &mut Context<'_>) -> Poll<()> {
-        Poll::Pending
+    pub fn poll_not_ready(&self, cx: &mut Context<'_>) -> Poll<()> {
+        let st = unsafe { &mut *self.not_ready.get() };
+
+        match st {
+            StateNotReady::New => {
+                // SAFETY: `fut` has same lifetime same as lifetime of `self.pl`.
+                // Pipeline::svc is heap allocated(Rc<S>), and it is being kept alive until
+                // `self` is alive
+                let pl: &'static Pipeline<S> = unsafe { std::mem::transmute(&self.pl) };
+                let fut = Box::pin(CheckUnReadiness {
+                    fut: None,
+                    f: not_ready,
+                    pl,
+                });
+                *st = StateNotReady::Readiness(fut);
+                self.poll_not_ready(cx)
+            }
+            StateNotReady::Readiness(ref mut fut) => Pin::new(fut).poll(cx),
+        }
    }

    #[inline]
@ -268,7 +263,6 @@ where
                // `self` is alive
                let pl: &'static Pipeline<S> = unsafe { std::mem::transmute(&self.pl) };
                *st = State::Shutdown(Box::pin(async move { pl.shutdown().await }));
-                pl.state.waiters.shutdown();
                self.poll_shutdown(cx)
            }
            State::Shutdown(ref mut fut) => Pin::new(fut).poll(cx),
@ -306,12 +300,6 @@ where
        }
    }

-    #[inline]
-    /// Check if shutdown is initiated.
-    pub fn is_shutdown(&self) -> bool {
-        self.pl.state.waiters.is_shutdown()
-    }
-
    #[inline]
    /// Shutdown enclosed service.
    pub async fn shutdown(&self) {
@ -337,6 +325,7 @@ where
        Self {
            pl: self.pl.clone(),
            st: cell::UnsafeCell::new(State::New),
+            not_ready: cell::UnsafeCell::new(StateNotReady::New),
        }
    }
 }
@ -395,16 +384,23 @@ where
        .ready(ServiceCtx::<'_, S>::new(pl.index, pl.state.waiters_ref()))
 }

-struct CheckReadiness<S: Service<R> + 'static, R, F, Fut> {
+fn not_ready<S, R>(pl: &'static Pipeline<S>) -> impl Future<Output = ()>
+where
+    S: Service<R>,
+    R: 'static,
+{
+    pl.state.svc.not_ready()
+}
+
+struct CheckReadiness<S: 'static, F, Fut> {
    f: F,
    fut: Option<Fut>,
    pl: &'static Pipeline<S>,
-    _t: marker::PhantomData<R>,
 }

-impl<S: Service<R>, R, F, Fut> Unpin for CheckReadiness<S, R, F, Fut> {}
+impl<S, F, Fut> Unpin for CheckReadiness<S, F, Fut> {}

-impl<S: Service<R>, R, F, Fut> Drop for CheckReadiness<S, R, F, Fut> {
+impl<S, F, Fut> Drop for CheckReadiness<S, F, Fut> {
    fn drop(&mut self) {
        // future fot dropped during polling, we must notify other waiters
        if self.fut.is_some() {
@ -413,19 +409,16 @@ impl<S: Service<R>, R, F, Fut> Drop for CheckReadiness<S, R, F, Fut> {
    }
 }

-impl<S, R, F, Fut> Future for CheckReadiness<S, R, F, Fut>
+impl<T, S, F, Fut> Future for CheckReadiness<S, F, Fut>
 where
-    S: Service<R>,
    F: Fn(&'static Pipeline<S>) -> Fut,
-    Fut: Future<Output = Result<(), S::Error>>,
+    Fut: Future<Output = T>,
 {
-    type Output = Result<(), S::Error>;
+    type Output = T;

-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<T> {
        let mut slf = self.as_mut();

-        slf.pl.poll(cx)?;
-
        if slf.pl.state.waiters.can_check(slf.pl.index, cx) {
            if slf.fut.is_none() {
                slf.fut = Some((slf.f)(slf.pl));
@ -447,3 +440,36 @@ where
        }
    }
 }
+
+struct CheckUnReadiness<S: 'static, F, Fut> {
+    f: F,
+    fut: Option<Fut>,
+    pl: &'static Pipeline<S>,
+}
+
+impl<S, F, Fut> Unpin for CheckUnReadiness<S, F, Fut> {}
+
+impl<T, S, F, Fut> Future for CheckUnReadiness<S, F, Fut>
+where
+    F: Fn(&'static Pipeline<S>) -> Fut,
+    Fut: Future<Output = T>,
+{
+    type Output = T;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<T> {
+        let mut slf = self.as_mut();
+
+        if slf.fut.is_none() {
+            slf.fut = Some((slf.f)(slf.pl));
+        }
+        let fut = slf.fut.as_mut().unwrap();
+        match unsafe { Pin::new_unchecked(fut) }.poll(cx) {
+            Poll::Pending => Poll::Pending,
+            Poll::Ready(res) => {
+                let _ = slf.fut.take();
+                slf.pl.state.waiters.notify();
+                Poll::Ready(res)
+            }
+        }
+    }
+}
--- a/ntex-service/src/then.rs
+++ b/ntex-service/src/then.rs
@ -31,9 +31,8 @@ where
    }

    #[inline]
-    fn poll(&self, cx: &mut std::task::Context<'_>) -> Result<(), Self::Error> {
-        self.svc1.poll(cx)?;
-        self.svc2.poll(cx)
+    async fn not_ready(&self) {
+        util::select(self.svc1.not_ready(), self.svc2.not_ready()).await
    }

    #[inline]
@ -92,8 +91,8 @@ where

 #[cfg(test)]
 mod tests {
-    use ntex_util::future::lazy;
-    use std::{cell::Cell, rc::Rc, task::Context};
+    use ntex_util::time;
+    use std::{cell::Cell, rc::Rc};

    use crate::{chain, chain_factory, fn_factory, Service, ServiceCtx};

@ -109,9 +108,9 @@ mod tests {
            Ok(())
        }

-        fn poll(&self, _: &mut Context<'_>) -> Result<(), Self::Error> {
+        async fn not_ready(&self) {
            self.0.set(self.0.get() + 1);
-            Ok(())
+            std::future::pending().await
        }

        async fn call(
@ -142,9 +141,9 @@ mod tests {
            Ok(())
        }

-        fn poll(&self, _: &mut Context<'_>) -> Result<(), Self::Error> {
+        async fn not_ready(&self) {
            self.0.set(self.0.get() + 1);
-            Ok(())
+            std::future::pending().await
        }

        async fn call(
@ -174,7 +173,11 @@ mod tests {
        assert_eq!(res, Ok(()));
        assert_eq!(cnt.get(), 2);

-        lazy(|cx| srv.clone().poll(cx)).await.unwrap();
+        let srv2 = srv.clone();
+        ntex::rt::spawn(async move {
+            let _ = srv2.not_ready().await;
+        });
+        time::sleep(time::Millis(25)).await;
        assert_eq!(cnt.get(), 4);

        srv.shutdown().await;
--- a/ntex-service/src/util.rs
+++ b/ntex-service/src/util.rs
@ -59,3 +59,24 @@ where
    })
    .await
 }
+
+/// Waits for either one of two differently-typed futures to complete.
+pub(crate) async fn select<A, B>(fut1: A, fut2: B) -> A::Output
+where
+    A: Future,
+    B: Future<Output = A::Output>,
+{
+    let mut fut1 = pin::pin!(fut1);
+    let mut fut2 = pin::pin!(fut2);
+
+    poll_fn(|cx| {
+        if let Poll::Ready(item) = Pin::new(&mut fut1).poll(cx) {
+            return Poll::Ready(item);
+        }
+        if let Poll::Ready(item) = Pin::new(&mut fut2).poll(cx) {
+            return Poll::Ready(item);
+        }
+        Poll::Pending
+    })
+    .await
+}
--- a/ntex-tls/CHANGES.md
+++ b/ntex-tls/CHANGES.md
@ -1,9 +1,5 @@
 # Changes

-## [2.4.0] - 2024-12-30
-
-* Enable rustls/std feature
-
 ## [2.3.0] - 2024-11-04

 * Use updated Service trait
--- a/ntex-tls/Cargo.toml
+++ b/ntex-tls/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "ntex-tls"
-version = "2.4.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"]
@ -22,14 +22,14 @@ default = []
 openssl = ["tls_openssl"]

 # rustls support
-rustls = ["tls_rust", "tls_rust/std"]
+rustls = ["tls_rust"]
 rustls-ring = ["tls_rust", "tls_rust/ring", "tls_rust/std"]

 [dependencies]
 ntex-bytes = "0.1"
 ntex-io = "2.3"
 ntex-util = "2.5"
-ntex-service = "3.4"
+ntex-service = "3.3"
 ntex-net = "2"

 log = "0.4"
--- a/ntex-tls/examples/rustls-server.rs
+++ b/ntex-tls/examples/rustls-server.rs
@ -13,8 +13,9 @@ async fn main() -> io::Result<()> {
    println!("Started openssl echp server: 127.0.0.1:8443");

    // load ssl keys
-    let cert_file = &mut BufReader::new(File::open("../examples/cert.pem").unwrap());
-    let key_file = &mut BufReader::new(File::open("../examples/key.pem").unwrap());
+    let cert_file =
+        &mut BufReader::new(File::open("../ntex-tls/examples/cert.pem").unwrap());
+    let key_file = &mut BufReader::new(File::open("../ntex-tls/examples/key.pem").unwrap());
    let keys = rustls_pemfile::private_key(key_file).unwrap().unwrap();
    let cert_chain = rustls_pemfile::certs(cert_file)
        .collect::<Result<Vec<_>, _>>()
--- a/ntex-tls/examples/webserver.rs
+++ b/ntex-tls/examples/webserver.rs
@ -8,18 +8,18 @@ use tls_openssl::ssl::{self, SslFiletype, SslMethod};

 #[ntex::main]
 async fn main() -> io::Result<()> {
-    std::env::set_var("RUST_LOG", "trace");
-    let _ = env_logger::try_init();
+    //std::env::set_var("RUST_LOG", "trace");
+    //env_logger::init();

    println!("Started openssl web server: 127.0.0.1:8443");

    // load ssl keys
    let mut builder = ssl::SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap();
    builder
-        .set_private_key_file("./examples/key.pem", SslFiletype::PEM)
+        .set_private_key_file("../tests/key.pem", SslFiletype::PEM)
        .unwrap();
    builder
-        .set_certificate_chain_file("./examples/cert.pem")
+        .set_certificate_chain_file("../tests/cert.pem")
        .unwrap();

    // h2 alpn config
--- a/ntex-tls/src/openssl/connect.rs
+++ b/ntex-tls/src/openssl/connect.rs
@ -51,11 +51,11 @@ impl<T: Address> SslConnector<T> {
        log::trace!("{}: SSL Handshake start for: {:?}", io.tag(), host);

        match openssl.configure() {
-            Err(e) => Err(io::Error::new(io::ErrorKind::InvalidInput, e).into()),
+            Err(e) => Err(io::Error::new(io::ErrorKind::Other, e).into()),
            Ok(config) => {
                let ssl = config
                    .into_ssl(&host)
-                    .map_err(|e| io::Error::new(io::ErrorKind::InvalidInput, e))?;
+                    .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
                let tag = io.tag();
                match connect_io(io, ssl).await {
                    Ok(io) => {
@ -64,10 +64,7 @@ impl<T: Address> SslConnector<T> {
                    }
                    Err(e) => {
                        log::trace!("{}: SSL Handshake error: {:?}", tag, e);
-                        Err(
-                            io::Error::new(io::ErrorKind::InvalidInput, format!("{}", e))
-                                .into(),
-                        )
+                        Err(io::Error::new(io::ErrorKind::Other, format!("{}", e)).into())
                    }
                }
            }
--- a/ntex-tls/src/openssl/mod.rs
+++ b/ntex-tls/src/openssl/mod.rs
@ -250,9 +250,7 @@ async fn handle_result<T, F>(
            ssl::ErrorCode::WANT_READ => {
                let res = io.read_notify().await;
                match res? {
-                    None => {
-                        Err(io::Error::new(io::ErrorKind::NotConnected, "disconnected"))
-                    }
+                    None => Err(io::Error::new(io::ErrorKind::Other, "disconnected")),
                    _ => Ok(None),
                }
            }
--- a/ntex-tls/src/rustls/mod.rs
+++ b/ntex-tls/src/rustls/mod.rs
@ -24,7 +24,7 @@ pub struct PeerCertChain<'a>(pub Vec<CertificateDer<'a>>);

 pub(crate) struct Wrapper<'a, 'b>(&'a WriteBuf<'b>);

-impl io::Read for Wrapper<'_, '_> {
+impl<'a, 'b> io::Read for Wrapper<'a, 'b> {
    fn read(&mut self, dst: &mut [u8]) -> io::Result<usize> {
        self.0.with_read_buf(|buf| {
            buf.with_src(|buf| {
@ -41,7 +41,7 @@ impl io::Read for Wrapper<'_, '_> {
    }
 }

-impl io::Write for Wrapper<'_, '_> {
+impl<'a, 'b> io::Write for Wrapper<'a, 'b> {
    fn write(&mut self, src: &[u8]) -> io::Result<usize> {
        self.0.with_dst(|buf| buf.extend_from_slice(src));
        Ok(src.len())
--- a/Show more
+++ b/Show more