Experimental poll based runtime (#510)

ntex-net/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ntex-net"
-version = "2.4.0"
+version = "2.5.0"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "ntexwork utils for ntex framework"
 keywords = ["network", "framework", "async", "futures"]
@@ -30,12 +30,15 @@ glommio = ["ntex-rt/glommio", "ntex-glommio"]
 # async-std runtime
 async-std = ["ntex-rt/async-std", "ntex-async-std"]
 
+# default ntex runtime
+default-rt = ["ntex-rt/default-rt", "ntex-runtime", "ntex-iodriver", "slab", "socket2"]
+
 [dependencies]
 ntex-service = "3.3"
 ntex-bytes = "0.1"
 ntex-http = "0.1"
-ntex-io = "2.8"
-ntex-rt = "0.4.21"
+ntex-io = "2.11"
+ntex-rt = "0.4.25"
 ntex-util = "2.5"
 
 ntex-tokio = { version = "0.5.3", optional = true }
@@ -43,8 +46,15 @@ ntex-compio = { version = "0.2.4", optional = true }
 ntex-glommio = { version = "0.5.2", optional = true }
 ntex-async-std = { version = "0.5.1", optional = true }
 
-log = "0.4"
-thiserror = "1"
+ntex-runtime = { version = "0.1.0", optional = true }
+ntex-iodriver = { version = "0.1.0", optional = true }
+
+bitflags = { workspace = true }
+log = { workspace = true }
+libc = { workspace = true }
+thiserror = { workspace = true }
+slab = { workspace = true, optional = true }
+socket2 = { workspace = true, optional = true }
 
 [dev-dependencies]
 ntex = "2"

ntex-net/src/compat.rs

@@ -6,10 +6,23 @@ 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 = "default-rt",
+    not(feature = "tokio"),
+    not(feature = "async-std"),
+    not(feature = "compio"),
+    not(feature = "glommio")
+))]
+pub use crate::rt::{
+    from_tcp_stream, from_unix_stream, tcp_connect, tcp_connect_in, unix_connect,
+    unix_connect_in,
+};
+
 #[cfg(all(
     feature = "compio",
     not(feature = "tokio"),
     not(feature = "async-std"),
+    not(feature = "default-rt"),
     not(feature = "glommio")
 ))]
 pub use ntex_compio::{from_tcp_stream, tcp_connect, tcp_connect_in};
@@ -19,6 +32,7 @@ pub use ntex_compio::{from_tcp_stream, tcp_connect, tcp_connect_in};
     feature = "compio",
     not(feature = "tokio"),
     not(feature = "async-std"),
+    not(feature = "default-rt"),
     not(feature = "glommio")
 ))]
 pub use ntex_compio::{from_unix_stream, unix_connect, unix_connect_in};
@@ -27,6 +41,7 @@ pub use ntex_compio::{from_unix_stream, unix_connect, unix_connect_in};
     feature = "async-std",
     not(feature = "tokio"),
     not(feature = "compio"),
+    not(feature = "default-rt"),
     not(feature = "glommio")
 ))]
 pub use ntex_async_std::{from_tcp_stream, tcp_connect, tcp_connect_in};
@@ -36,6 +51,7 @@ pub use ntex_async_std::{from_tcp_stream, tcp_connect, tcp_connect_in};
     feature = "async-std",
     not(feature = "tokio"),
     not(feature = "compio"),
+    not(feature = "default-rt"),
     not(feature = "glommio")
 ))]
 pub use ntex_async_std::{from_unix_stream, unix_connect, unix_connect_in};
@@ -44,6 +60,7 @@ pub use ntex_async_std::{from_unix_stream, unix_connect, unix_connect_in};
     feature = "glommio",
     not(feature = "tokio"),
     not(feature = "compio"),
+    not(feature = "default-rt"),
     not(feature = "async-std")
 ))]
 pub use ntex_glommio::{from_tcp_stream, tcp_connect, tcp_connect_in};
@@ -53,6 +70,7 @@ pub use ntex_glommio::{from_tcp_stream, tcp_connect, tcp_connect_in};
     feature = "glommio",
     not(feature = "tokio"),
     not(feature = "compio"),
+    not(feature = "default-rt"),
     not(feature = "async-std")
 ))]
 pub use ntex_glommio::{from_unix_stream, unix_connect, unix_connect_in};
@@ -61,6 +79,7 @@ pub use ntex_glommio::{from_unix_stream, unix_connect, unix_connect_in};
     not(feature = "tokio"),
     not(feature = "compio"),
     not(feature = "async-std"),
+    not(feature = "default-rt"),
     not(feature = "glommio")
 ))]
 mod no_rt {
@@ -131,6 +150,7 @@ mod no_rt {
     not(feature = "tokio"),
     not(feature = "compio"),
     not(feature = "async-std"),
+    not(feature = "default-rt"),
     not(feature = "glommio")
 ))]
 pub use no_rt::*;

ntex-net/src/lib.rs

@@ -8,3 +8,12 @@ pub use ntex_io::Io;
 pub use ntex_rt::{spawn, spawn_blocking};
 
 pub use self::compat::*;
+
+#[cfg(all(
+    feature = "default-rt",
+    not(feature = "tokio"),
+    not(feature = "async-std"),
+    not(feature = "compio"),
+    not(feature = "glommio")
+))]
+mod rt;

ntex-net/src/rt/connect.rs

@@ -0,0 +1,196 @@
+use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6};
+use std::{cell::RefCell, collections::VecDeque, io, path::Path, rc::Rc, task::Poll};
+
+use ntex_iodriver::op::{Handler, Interest};
+use ntex_iodriver::{syscall, AsRawFd, DriverApi, RawFd};
+use ntex_runtime::net::{Socket, TcpStream, UnixStream};
+use ntex_runtime::Runtime;
+use ntex_util::channel::oneshot::{channel, Sender};
+use slab::Slab;
+use socket2::{Protocol, SockAddr, Type};
+
+pub(crate) async fn connect(addr: SocketAddr) -> io::Result<TcpStream> {
+    let addr = SockAddr::from(addr);
+    let socket = if cfg!(windows) {
+        let bind_addr = if addr.is_ipv4() {
+            SockAddr::from(SocketAddrV4::new(Ipv4Addr::UNSPECIFIED, 0))
+        } else if addr.is_ipv6() {
+            SockAddr::from(SocketAddrV6::new(Ipv6Addr::UNSPECIFIED, 0, 0, 0))
+        } else {
+            return Err(io::Error::new(
+                io::ErrorKind::AddrNotAvailable,
+                "Unsupported address domain.",
+            ));
+        };
+        Socket::bind(&bind_addr, Type::STREAM, Some(Protocol::TCP)).await?
+    } else {
+        Socket::new(addr.domain(), Type::STREAM, Some(Protocol::TCP)).await?
+    };
+
+    let (sender, rx) = channel();
+
+    ConnectOps::current().connect(socket.as_raw_fd(), addr, sender)?;
+
+    rx.await
+        .map_err(|_| io::Error::new(io::ErrorKind::Other, "IO Driver is gone"))
+        .and_then(|item| item)?;
+
+    Ok(TcpStream::from_socket(socket))
+}
+
+pub(crate) async fn connect_unix(path: impl AsRef<Path>) -> io::Result<UnixStream> {
+    let addr = SockAddr::unix(path)?;
+
+    #[cfg(windows)]
+    let socket = {
+        let new_addr = empty_unix_socket();
+        Socket::bind(&new_addr, Type::STREAM, None).await?
+    };
+    #[cfg(unix)]
+    let socket = {
+        use socket2::Domain;
+        Socket::new(Domain::UNIX, Type::STREAM, None).await?
+    };
+
+    let (sender, rx) = channel();
+
+    ConnectOps::current().connect(socket.as_raw_fd(), addr, sender)?;
+
+    rx.await
+        .map_err(|_| io::Error::new(io::ErrorKind::Other, "IO Driver is gone"))
+        .and_then(|item| item)?;
+
+    Ok(UnixStream::from_socket(socket))
+}
+
+#[derive(Clone)]
+pub(crate) struct ConnectOps(Rc<ConnectOpsInner>);
+
+#[derive(Debug)]
+enum Change {
+    Readable,
+    Writable,
+    Error(io::Error),
+}
+
+struct ConnectOpsBatcher {
+    feed: VecDeque<(usize, Change)>,
+    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::with_current(|rt| {
+            if let Some(s) = rt.get::<Self>() {
+                s
+            } else {
+                let mut inner = None;
+                rt.driver().register_handler(|api| {
+                    let ops = Rc::new(ConnectOpsInner {
+                        api,
+                        connects: RefCell::new(Slab::new()),
+                    });
+                    inner = Some(ops.clone());
+                    Box::new(ConnectOpsBatcher {
+                        inner: ops,
+                        feed: VecDeque::new(),
+                    })
+                });
+
+                let s = ConnectOps(inner.unwrap());
+                rt.insert(s.clone());
+                s
+            }
+        })
+    }
+
+    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.register(fd, id, Interest::Writable);
+
+        Ok(id)
+    }
+}
+
+impl Handler for ConnectOpsBatcher {
+    fn readable(&mut self, id: usize) {
+        log::debug!("ConnectFD is readable {:?}", id);
+        self.feed.push_back((id, Change::Readable));
+    }
+
+    fn writable(&mut self, id: usize) {
+        log::debug!("ConnectFD is writable {:?}", id);
+        self.feed.push_back((id, Change::Writable));
+    }
+
+    fn error(&mut self, id: usize, err: io::Error) {
+        self.feed.push_back((id, Change::Error(err)));
+    }
+
+    fn commit(&mut self) {
+        if self.feed.is_empty() {
+            return;
+        }
+        log::debug!("Commit connect driver changes, num: {:?}", self.feed.len());
+
+        let mut connects = self.inner.connects.borrow_mut();
+
+        for (id, change) in self.feed.drain(..) {
+            if connects.contains(id) {
+                let item = connects.remove(id);
+                match change {
+                    Change::Readable => unreachable!(),
+                    Change::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.unregister_all(item.fd);
+                        let _ = item.sender.send(res);
+                    }
+                    Change::Error(err) => {
+                        let _ = item.sender.send(Err(err));
+                        self.inner.api.unregister_all(item.fd);
+                    }
+                }
+            }
+        }
+    }
+}

ntex-net/src/rt/driver.rs

@@ -0,0 +1,362 @@
+use std::{cell::Cell, collections::VecDeque, fmt, io, ptr, rc::Rc, task, task::Poll};
+
+use ntex_iodriver::op::{Handler, Interest};
+use ntex_iodriver::{syscall, AsRawFd, DriverApi, RawFd};
+use ntex_runtime::Runtime;
+use slab::Slab;
+
+use ntex_bytes::BufMut;
+use ntex_io::IoContext;
+
+bitflags::bitflags! {
+    #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+    struct Flags: u8 {
+        const ERROR = 0b0000_0001;
+        const RD    = 0b0000_0010;
+        const WR    = 0b0000_0100;
+    }
+}
+
+pub(crate) struct StreamCtl<T> {
+    id: usize,
+    inner: Rc<CompioOpsInner<T>>,
+}
+
+struct TcpStreamItem<T> {
+    io: Option<T>,
+    fd: RawFd,
+    context: IoContext,
+    flags: Flags,
+    ref_count: usize,
+}
+
+pub(crate) struct CompioOps<T>(Rc<CompioOpsInner<T>>);
+
+#[derive(Debug)]
+enum Change {
+    Readable,
+    Writable,
+    Error(io::Error),
+}
+
+struct CompioOpsBatcher<T> {
+    feed: VecDeque<(usize, Change)>,
+    inner: Rc<CompioOpsInner<T>>,
+}
+
+struct CompioOpsInner<T> {
+    api: DriverApi,
+    feed: Cell<Option<VecDeque<usize>>>,
+    streams: Cell<Option<Box<Slab<TcpStreamItem<T>>>>>,
+}
+
+impl<T: AsRawFd + 'static> CompioOps<T> {
+    pub(crate) fn current() -> Self {
+        Runtime::with_current(|rt| {
+            if let Some(s) = rt.get::<Self>() {
+                s
+            } else {
+                let mut inner = None;
+                rt.driver().register_handler(|api| {
+                    let ops = Rc::new(CompioOpsInner {
+                        api,
+                        feed: Cell::new(Some(VecDeque::new())),
+                        streams: Cell::new(Some(Box::new(Slab::new()))),
+                    });
+                    inner = Some(ops.clone());
+                    Box::new(CompioOpsBatcher {
+                        inner: ops,
+                        feed: VecDeque::new(),
+                    })
+                });
+
+                let s = CompioOps(inner.unwrap());
+                rt.insert(s.clone());
+                s
+            }
+        })
+    }
+
+    pub(crate) fn register(&self, io: T, context: IoContext) -> StreamCtl<T> {
+        let item = TcpStreamItem {
+            context,
+            fd: io.as_raw_fd(),
+            io: Some(io),
+            flags: Flags::empty(),
+            ref_count: 1,
+        };
+        self.with(|streams| {
+            let id = streams.insert(item);
+            StreamCtl {
+                id,
+                inner: self.0.clone(),
+            }
+        })
+    }
+
+    fn with<F, R>(&self, f: F) -> R
+    where
+        F: FnOnce(&mut Slab<TcpStreamItem<T>>) -> R,
+    {
+        let mut inner = self.0.streams.take().unwrap();
+        let result = f(&mut inner);
+        self.0.streams.set(Some(inner));
+        result
+    }
+}
+
+impl<T> Clone for CompioOps<T> {
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+}
+
+impl<T> Handler for CompioOpsBatcher<T> {
+    fn readable(&mut self, id: usize) {
+        log::debug!("FD is readable {:?}", id);
+        self.feed.push_back((id, Change::Readable));
+    }
+
+    fn writable(&mut self, id: usize) {
+        log::debug!("FD is writable {:?}", id);
+        self.feed.push_back((id, Change::Writable));
+    }
+
+    fn error(&mut self, id: usize, err: io::Error) {
+        log::debug!("FD is failed {:?}, err: {:?}", id, err);
+        self.feed.push_back((id, Change::Error(err)));
+    }
+
+    fn commit(&mut self) {
+        if self.feed.is_empty() {
+            return;
+        }
+        log::debug!("Commit changes, num: {:?}", self.feed.len());
+
+        let mut streams = self.inner.streams.take().unwrap();
+
+        for (id, change) in self.feed.drain(..) {
+            match change {
+                Change::Readable => {
+                    let item = &mut streams[id];
+                    let result = item.context.with_read_buf(|buf| {
+                        let chunk = buf.chunk_mut();
+                        let b = chunk.as_mut_ptr();
+                        Poll::Ready(
+                            task::ready!(syscall!(
+                                break libc::read(item.fd, b as _, chunk.len())
+                            ))
+                            .inspect(|size| {
+                                unsafe { buf.advance_mut(*size) };
+                                log::debug!(
+                                    "FD: {:?}, SIZE: {:?}, BUF: {:?}",
+                                    item.fd,
+                                    size,
+                                    buf
+                                );
+                            }),
+                        )
+                    });
+
+                    if result.is_pending() {
+                        item.flags.insert(Flags::RD);
+                        self.inner.api.register(item.fd, id, Interest::Readable);
+                    }
+                }
+                Change::Writable => {
+                    let item = &mut streams[id];
+                    let result = item.context.with_write_buf(|buf| {
+                        let slice = &buf[..];
+                        syscall!(
+                            break libc::write(item.fd, slice.as_ptr() as _, slice.len())
+                        )
+                    });
+
+                    if result.is_pending() {
+                        item.flags.insert(Flags::WR);
+                        self.inner.api.register(item.fd, id, Interest::Writable);
+                    }
+                }
+                Change::Error(err) => {
+                    if let Some(item) = streams.get_mut(id) {
+                        item.context.stopped(Some(err));
+                        if !item.flags.contains(Flags::ERROR) {
+                            item.flags.insert(Flags::ERROR);
+                            item.flags.remove(Flags::RD | Flags::WR);
+                            self.inner.api.unregister_all(item.fd);
+                        }
+                    }
+                }
+            }
+        }
+
+        // extra
+        let mut feed = self.inner.feed.take().unwrap();
+        for id in feed.drain(..) {
+            log::debug!("Drop io ({}), {:?}", id, streams[id].fd);
+
+            streams[id].ref_count -= 1;
+            if streams[id].ref_count == 0 {
+                let item = streams.remove(id);
+                if item.io.is_some() {
+                    self.inner.api.unregister_all(item.fd);
+                }
+            }
+        }
+
+        self.inner.feed.set(Some(feed));
+        self.inner.streams.set(Some(streams));
+    }
+}
+
+pub(crate) trait Closable {
+    async fn close(self) -> io::Result<()>;
+}
+
+impl<T> StreamCtl<T> {
+    pub(crate) async fn close(self) -> io::Result<()>
+    where
+        T: Closable,
+    {
+        if let Some(io) = self.with(|streams| streams[self.id].io.take()) {
+            io.close().await
+        } else {
+            Ok(())
+        }
+    }
+
+    pub(crate) fn with_io<F, R>(&self, f: F) -> R
+    where
+        F: FnOnce(Option<&T>) -> R,
+    {
+        self.with(|streams| f(streams[self.id].io.as_ref()))
+    }
+
+    pub(crate) fn pause_all(&self) {
+        self.with(|streams| {
+            let item = &mut streams[self.id];
+
+            if item.flags.intersects(Flags::RD | Flags::WR) {
+                log::debug!("Pause all io ({}), {:?}", self.id, item.fd);
+                item.flags.remove(Flags::RD | Flags::WR);
+                self.inner.api.unregister_all(item.fd);
+            }
+        })
+    }
+
+    pub(crate) fn pause_read(&self) {
+        self.with(|streams| {
+            let item = &mut streams[self.id];
+
+            log::debug!("Pause io read ({}), {:?}", self.id, item.fd);
+            if item.flags.contains(Flags::RD) {
+                item.flags.remove(Flags::RD);
+                self.inner.api.unregister(item.fd, Interest::Readable);
+            }
+        })
+    }
+
+    pub(crate) fn resume_read(&self) {
+        self.with(|streams| {
+            let item = &mut streams[self.id];
+
+            log::debug!("Resume io read ({}), {:?}", self.id, item.fd);
+            if !item.flags.contains(Flags::RD) {
+                item.flags.insert(Flags::RD);
+                self.inner
+                    .api
+                    .register(item.fd, self.id, Interest::Readable);
+            }
+        })
+    }
+
+    pub(crate) fn resume_write(&self) {
+        self.with(|streams| {
+            let item = &mut streams[self.id];
+
+            if !item.flags.contains(Flags::WR) {
+                log::debug!("Resume io write ({}), {:?}", self.id, item.fd);
+                let result = item.context.with_write_buf(|buf| {
+                    log::debug!("Writing io ({}), buf: {:?}", self.id, buf.len());
+
+                    let slice = &buf[..];
+                    syscall!(break libc::write(item.fd, slice.as_ptr() as _, slice.len()))
+                });
+
+                if result.is_pending() {
+                    log::debug!(
+                        "Write is pending ({}), {:?}",
+                        self.id,
+                        item.context.flags()
+                    );
+
+                    item.flags.insert(Flags::WR);
+                    self.inner
+                        .api
+                        .register(item.fd, self.id, Interest::Writable);
+                }
+            }
+        })
+    }
+
+    fn with<F, R>(&self, f: F) -> R
+    where
+        F: FnOnce(&mut Slab<TcpStreamItem<T>>) -> R,
+    {
+        let mut inner = self.inner.streams.take().unwrap();
+        let result = f(&mut inner);
+        self.inner.streams.set(Some(inner));
+        result
+    }
+}
+
+impl<T> Clone for StreamCtl<T> {
+    fn clone(&self) -> Self {
+        self.with(|streams| {
+            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 Some(mut streams) = self.inner.streams.take() {
+            log::debug!("Drop io ({}), {:?}", self.id, streams[self.id].fd);
+
+            streams[self.id].ref_count -= 1;
+            if streams[self.id].ref_count == 0 {
+                let item = streams.remove(self.id);
+                if item.io.is_some() {
+                    self.inner.api.unregister_all(item.fd);
+                }
+            }
+            self.inner.streams.set(Some(streams));
+        } else {
+            let mut feed = self.inner.feed.take().unwrap();
+            feed.push_back(self.id);
+            self.inner.feed.set(Some(feed));
+        }
+    }
+}
+
+impl<T> PartialEq for StreamCtl<T> {
+    #[inline]
+    fn eq(&self, other: &StreamCtl<T>) -> bool {
+        self.id == other.id && ptr::eq(&self.inner, &other.inner)
+    }
+}
+
+impl<T: fmt::Debug> fmt::Debug for StreamCtl<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.with(|streams| {
+            f.debug_struct("StreamCtl")
+                .field("id", &self.id)
+                .field("io", &streams[self.id].io)
+                .finish()
+        })
+    }
+}

ntex-net/src/rt/io.rs

@@ -0,0 +1,107 @@
+use std::{any, future::poll_fn, io, task::Poll};
+
+use ntex_io::{
+    types, Handle, IoContext, IoStream, ReadContext, ReadStatus, WriteContext, WriteStatus,
+};
+use ntex_runtime::{net::TcpStream, net::UnixStream, spawn};
+
+use super::driver::{Closable, CompioOps, StreamCtl};
+
+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 = CompioOps::current().register(io, context.clone());
+        let ctl2 = ctl.clone();
+        spawn(async move { run(ctl, context).await }).detach();
+
+        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 = CompioOps::current().register(io, context.clone());
+        spawn(async move { run(ctl, context).await }).detach();
+
+        None
+    }
+}
+
+struct HandleWrapper(StreamCtl<TcpStream>);
+
+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 {
+                return Some(Box::new(types::PeerAddr(addr)));
+            }
+        }
+        None
+    }
+}
+
+impl Closable for TcpStream {
+    async fn close(self) -> io::Result<()> {
+        TcpStream::close(self).await
+    }
+}
+
+impl Closable for UnixStream {
+    async fn close(self) -> io::Result<()> {
+        UnixStream::close(self).await
+    }
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+enum Status {
+    Shutdown,
+    Terminate,
+}
+
+async fn run<T: Closable>(ctl: StreamCtl<T>, context: IoContext) {
+    // Handle io read 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.resume_write();
+    context.shutdown(st == Status::Shutdown).await;
+
+    ctl.pause_all();
+    let result = ctl.close().await;
+
+    context.stopped(result.err());
+}

ntex-net/src/rt/mod.rs

@@ -0,0 +1,60 @@
+#![allow(clippy::type_complexity)]
+use std::{io::Result, net, net::SocketAddr};
+
+use ntex_bytes::PoolRef;
+use ntex_io::Io;
+
+mod connect;
+mod driver;
+mod io;
+
+/// Tcp stream wrapper for compio TcpStream
+struct TcpStream(ntex_runtime::net::TcpStream);
+
+/// Tcp stream wrapper for compio UnixStream
+struct UnixStream(ntex_runtime::net::UnixStream);
+
+/// Opens a TCP connection to a remote host.
+pub async fn tcp_connect(addr: SocketAddr) -> Result<Io> {
+    let sock = connect::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 = connect::connect(addr).await?;
+    Ok(Io::with_memory_pool(TcpStream(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 = connect::connect_unix(addr).await?;
+    Ok(Io::new(UnixStream(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 = connect::connect_unix(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(ntex_runtime::net::TcpStream::from_std(
+        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(
+        ntex_runtime::net::UnixStream::from_std(stream)?,
+    )))
+}