mirror of
https://github.com/ntex-rs/ntex.git
synced 2025-04-03 21:07:39 +03:00
Add io-uring driver (#515)
This commit is contained in:
Nikolay Kim
GitHub
parent
47afec7351
commit
60a686b2f6
38 changed files with 1700 additions and 277 deletions
|
|
@ -1,8 +1,8 @@
|
|||
# Changes
|
||||
|
||||
## [2.5.0] - 2025-03-10
|
||||
## [2.5.0] - 2025-03-12
|
||||
|
||||
* Add ntex-runtime support
|
||||
* Add neon runtime support
|
||||
|
||||
* Drop glommio support
|
||||
|
||||
|
|
|
|||
|
|
@ -24,8 +24,11 @@ tokio = ["ntex-rt/tokio", "ntex-tokio"]
|
|||
# compio runtime
|
||||
compio = ["ntex-rt/compio", "ntex-compio"]
|
||||
|
||||
# default ntex runtime
|
||||
neon = ["ntex-rt/neon", "ntex-neon", "slab", "socket2"]
|
||||
# neon runtime
|
||||
neon = ["ntex-rt/neon", "ntex-neon/polling", "slab", "socket2"]
|
||||
|
||||
# neon io-uring runtime
|
||||
neon-uring = ["ntex-rt/neon", "ntex-neon/io-uring", "io-uring", "slab", "socket2"]
|
||||
|
||||
[dependencies]
|
||||
ntex-service = "3.3"
|
||||
|
|
@ -46,6 +49,10 @@ thiserror = { workspace = true }
|
|||
slab = { workspace = true, optional = true }
|
||||
socket2 = { workspace = true, optional = true }
|
||||
|
||||
# Linux specific dependencies
|
||||
[target.'cfg(target_os = "linux")'.dependencies]
|
||||
io-uring = { workspace = true, optional = true }
|
||||
|
||||
[dev-dependencies]
|
||||
ntex = "2"
|
||||
env_logger = "0.11"
|
||||
|
|
|
|||
|
|
@ -6,24 +6,53 @@ 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 = "neon", not(feature = "tokio"), not(feature = "compio")))]
|
||||
pub use crate::rt::{
|
||||
#[cfg(all(
|
||||
feature = "neon",
|
||||
not(feature = "neon-uring"),
|
||||
not(feature = "tokio"),
|
||||
not(feature = "compio")
|
||||
))]
|
||||
pub use crate::rt_polling::{
|
||||
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 = "neon")))]
|
||||
#[cfg(all(
|
||||
feature = "neon-uring",
|
||||
not(feature = "neon"),
|
||||
not(feature = "tokio"),
|
||||
not(feature = "compio"),
|
||||
target_os = "linux",
|
||||
feature = "io-uring"
|
||||
))]
|
||||
pub use crate::rt_uring::{
|
||||
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 = "neon"),
|
||||
not(feature = "neon-uring")
|
||||
))]
|
||||
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 = "neon"),
|
||||
not(feature = "neon-uring")
|
||||
))]
|
||||
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(
|
||||
not(feature = "tokio"),
|
||||
not(feature = "compio"),
|
||||
not(feature = "neon"),
|
||||
not(feature = "neon-uring")
|
||||
))]
|
||||
mod no_rt {
|
||||
use ntex_io::Io;
|
||||
|
||||
|
|
@ -88,5 +117,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 = "neon"),
|
||||
not(feature = "neon-uring")
|
||||
))]
|
||||
pub use no_rt::*;
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
//! Utility for async runtime abstraction
|
||||
#![deny(rust_2018_idioms, unreachable_pub, missing_debug_implementations)]
|
||||
#![allow(unused_variables, dead_code)]
|
||||
|
||||
mod compat;
|
||||
pub mod connect;
|
||||
|
|
@ -9,5 +10,20 @@ pub use ntex_rt::{spawn, spawn_blocking};
|
|||
|
||||
pub use self::compat::*;
|
||||
|
||||
#[cfg(all(feature = "neon", not(feature = "tokio"), not(feature = "compio")))]
|
||||
mod rt;
|
||||
#[cfg(all(
|
||||
feature = "neon",
|
||||
not(feature = "neon-uring"),
|
||||
not(feature = "tokio"),
|
||||
not(feature = "compio")
|
||||
))]
|
||||
mod rt_polling;
|
||||
|
||||
#[cfg(all(
|
||||
feature = "neon-uring",
|
||||
not(feature = "neon"),
|
||||
not(feature = "tokio"),
|
||||
not(feature = "compio"),
|
||||
target_os = "linux",
|
||||
feature = "io-uring"
|
||||
))]
|
||||
mod rt_uring;
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
use std::{cell::Cell, collections::VecDeque, fmt, io, ptr, rc::Rc, task, task::Poll};
|
||||
|
||||
use ntex_neon::driver::op::{Handler, Interest};
|
||||
use ntex_neon::driver::op::{CloseSocket, Handler, Interest};
|
||||
use ntex_neon::driver::{AsRawFd, DriverApi, RawFd};
|
||||
use ntex_neon::{syscall, Runtime};
|
||||
use slab::Slab;
|
||||
|
|
@ -19,10 +19,10 @@ bitflags::bitflags! {
|
|||
|
||||
pub(crate) struct StreamCtl<T> {
|
||||
id: usize,
|
||||
inner: Rc<CompioOpsInner<T>>,
|
||||
inner: Rc<StreamOpsInner<T>>,
|
||||
}
|
||||
|
||||
struct TcpStreamItem<T> {
|
||||
struct StreamItem<T> {
|
||||
io: Option<T>,
|
||||
fd: RawFd,
|
||||
context: IoContext,
|
||||
|
|
@ -30,7 +30,7 @@ struct TcpStreamItem<T> {
|
|||
ref_count: usize,
|
||||
}
|
||||
|
||||
pub(crate) struct CompioOps<T>(Rc<CompioOpsInner<T>>);
|
||||
pub(crate) struct StreamOps<T>(Rc<StreamOpsInner<T>>);
|
||||
|
||||
#[derive(Debug)]
|
||||
enum Change {
|
||||
|
|
@ -39,18 +39,18 @@ enum Change {
|
|||
Error(io::Error),
|
||||
}
|
||||
|
||||
struct CompioOpsBatcher<T> {
|
||||
struct StreamOpsHandler<T> {
|
||||
feed: VecDeque<(usize, Change)>,
|
||||
inner: Rc<CompioOpsInner<T>>,
|
||||
inner: Rc<StreamOpsInner<T>>,
|
||||
}
|
||||
|
||||
struct CompioOpsInner<T> {
|
||||
struct StreamOpsInner<T> {
|
||||
api: DriverApi,
|
||||
feed: Cell<Option<VecDeque<usize>>>,
|
||||
streams: Cell<Option<Box<Slab<TcpStreamItem<T>>>>>,
|
||||
streams: Cell<Option<Box<Slab<StreamItem<T>>>>>,
|
||||
}
|
||||
|
||||
impl<T: AsRawFd + 'static> CompioOps<T> {
|
||||
impl<T: AsRawFd + 'static> StreamOps<T> {
|
||||
pub(crate) fn current() -> Self {
|
||||
Runtime::with_current(|rt| {
|
||||
if let Some(s) = rt.get::<Self>() {
|
||||
|
|
@ -58,19 +58,19 @@ impl<T: AsRawFd + 'static> CompioOps<T> {
|
|||
} else {
|
||||
let mut inner = None;
|
||||
rt.driver().register_handler(|api| {
|
||||
let ops = Rc::new(CompioOpsInner {
|
||||
let ops = Rc::new(StreamOpsInner {
|
||||
api,
|
||||
feed: Cell::new(Some(VecDeque::new())),
|
||||
streams: Cell::new(Some(Box::new(Slab::new()))),
|
||||
});
|
||||
inner = Some(ops.clone());
|
||||
Box::new(CompioOpsBatcher {
|
||||
Box::new(StreamOpsHandler {
|
||||
inner: ops,
|
||||
feed: VecDeque::new(),
|
||||
})
|
||||
});
|
||||
|
||||
let s = CompioOps(inner.unwrap());
|
||||
let s = StreamOps(inner.unwrap());
|
||||
rt.insert(s.clone());
|
||||
s
|
||||
}
|
||||
|
|
@ -78,7 +78,7 @@ impl<T: AsRawFd + 'static> CompioOps<T> {
|
|||
}
|
||||
|
||||
pub(crate) fn register(&self, io: T, context: IoContext) -> StreamCtl<T> {
|
||||
let item = TcpStreamItem {
|
||||
let item = StreamItem {
|
||||
context,
|
||||
fd: io.as_raw_fd(),
|
||||
io: Some(io),
|
||||
|
|
@ -96,7 +96,7 @@ impl<T: AsRawFd + 'static> CompioOps<T> {
|
|||
|
||||
fn with<F, R>(&self, f: F) -> R
|
||||
where
|
||||
F: FnOnce(&mut Slab<TcpStreamItem<T>>) -> R,
|
||||
F: FnOnce(&mut Slab<StreamItem<T>>) -> R,
|
||||
{
|
||||
let mut inner = self.0.streams.take().unwrap();
|
||||
let result = f(&mut inner);
|
||||
|
|
@ -105,13 +105,13 @@ impl<T: AsRawFd + 'static> CompioOps<T> {
|
|||
}
|
||||
}
|
||||
|
||||
impl<T> Clone for CompioOps<T> {
|
||||
impl<T> Clone for StreamOps<T> {
|
||||
fn clone(&self) -> Self {
|
||||
Self(self.0.clone())
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> Handler for CompioOpsBatcher<T> {
|
||||
impl<T> Handler for StreamOpsHandler<T> {
|
||||
fn readable(&mut self, id: usize) {
|
||||
log::debug!("FD is readable {:?}", id);
|
||||
self.feed.push_back((id, Change::Readable));
|
||||
|
|
@ -149,7 +149,8 @@ impl<T> Handler for CompioOpsBatcher<T> {
|
|||
.inspect(|size| {
|
||||
unsafe { buf.advance_mut(*size) };
|
||||
log::debug!(
|
||||
"FD: {:?}, SIZE: {:?}, BUF: {:?}",
|
||||
"{}: {:?}, SIZE: {:?}, BUF: {:?}",
|
||||
item.context.tag(),
|
||||
item.fd,
|
||||
size,
|
||||
buf
|
||||
|
|
@ -193,10 +194,11 @@ impl<T> Handler for CompioOpsBatcher<T> {
|
|||
// extra
|
||||
let mut feed = self.inner.feed.take().unwrap();
|
||||
for id in feed.drain(..) {
|
||||
log::debug!("Drop io ({}), {:?}", id, streams[id].fd);
|
||||
let item = &mut streams[id];
|
||||
log::debug!("{}: Drop io ({}), {:?}", item.context.tag(), id, item.fd);
|
||||
|
||||
streams[id].ref_count -= 1;
|
||||
if streams[id].ref_count == 0 {
|
||||
item.ref_count -= 1;
|
||||
if item.ref_count == 0 {
|
||||
let item = streams.remove(id);
|
||||
if item.io.is_some() {
|
||||
self.inner.api.unregister_all(item.fd);
|
||||
|
|
@ -209,20 +211,17 @@ impl<T> Handler for CompioOpsBatcher<T> {
|
|||
}
|
||||
}
|
||||
|
||||
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) async fn close(self) -> io::Result<()> {
|
||||
let (io, fd) =
|
||||
self.with(|streams| (streams[self.id].io.take(), streams[self.id].fd));
|
||||
if let Some(io) = io {
|
||||
let op = CloseSocket::from_raw_fd(fd);
|
||||
let fut = ntex_neon::submit(op);
|
||||
std::mem::forget(io);
|
||||
fut.await.0?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(crate) fn with_io<F, R>(&self, f: F) -> R
|
||||
|
|
@ -237,7 +236,12 @@ impl<T> StreamCtl<T> {
|
|||
let item = &mut streams[self.id];
|
||||
|
||||
if item.flags.intersects(Flags::RD | Flags::WR) {
|
||||
log::debug!("Pause all io ({}), {:?}", self.id, item.fd);
|
||||
log::debug!(
|
||||
"{}: Pause all io ({}), {:?}",
|
||||
item.context.tag(),
|
||||
self.id,
|
||||
item.fd
|
||||
);
|
||||
item.flags.remove(Flags::RD | Flags::WR);
|
||||
self.inner.api.unregister_all(item.fd);
|
||||
}
|
||||
|
|
@ -248,7 +252,12 @@ impl<T> StreamCtl<T> {
|
|||
self.with(|streams| {
|
||||
let item = &mut streams[self.id];
|
||||
|
||||
log::debug!("Pause io read ({}), {:?}", self.id, item.fd);
|
||||
log::debug!(
|
||||
"{}: Pause io read ({}), {:?}",
|
||||
item.context.tag(),
|
||||
self.id,
|
||||
item.fd
|
||||
);
|
||||
if item.flags.contains(Flags::RD) {
|
||||
item.flags.remove(Flags::RD);
|
||||
self.inner.api.unregister(item.fd, Interest::Readable);
|
||||
|
|
@ -260,7 +269,12 @@ impl<T> StreamCtl<T> {
|
|||
self.with(|streams| {
|
||||
let item = &mut streams[self.id];
|
||||
|
||||
log::debug!("Resume io read ({}), {:?}", self.id, item.fd);
|
||||
log::debug!(
|
||||
"{}: Resume io read ({}), {:?}",
|
||||
item.context.tag(),
|
||||
self.id,
|
||||
item.fd
|
||||
);
|
||||
if !item.flags.contains(Flags::RD) {
|
||||
item.flags.insert(Flags::RD);
|
||||
self.inner
|
||||
|
|
@ -275,9 +289,19 @@ impl<T> StreamCtl<T> {
|
|||
let item = &mut streams[self.id];
|
||||
|
||||
if !item.flags.contains(Flags::WR) {
|
||||
log::debug!("Resume io write ({}), {:?}", self.id, item.fd);
|
||||
log::debug!(
|
||||
"{}: Resume io write ({}), {:?}",
|
||||
item.context.tag(),
|
||||
self.id,
|
||||
item.fd
|
||||
);
|
||||
let result = item.context.with_write_buf(|buf| {
|
||||
log::debug!("Writing io ({}), buf: {:?}", self.id, buf.len());
|
||||
log::debug!(
|
||||
"{}: Writing io ({}), buf: {:?}",
|
||||
item.context.tag(),
|
||||
self.id,
|
||||
buf.len()
|
||||
);
|
||||
|
||||
let slice = &buf[..];
|
||||
syscall!(break libc::write(item.fd, slice.as_ptr() as _, slice.len()))
|
||||
|
|
@ -285,7 +309,8 @@ impl<T> StreamCtl<T> {
|
|||
|
||||
if result.is_pending() {
|
||||
log::debug!(
|
||||
"Write is pending ({}), {:?}",
|
||||
"{}: Write is pending ({}), {:?}",
|
||||
item.context.tag(),
|
||||
self.id,
|
||||
item.context.flags()
|
||||
);
|
||||
|
|
@ -301,7 +326,7 @@ impl<T> StreamCtl<T> {
|
|||
|
||||
fn with<F, R>(&self, f: F) -> R
|
||||
where
|
||||
F: FnOnce(&mut Slab<TcpStreamItem<T>>) -> R,
|
||||
F: FnOnce(&mut Slab<StreamItem<T>>) -> R,
|
||||
{
|
||||
let mut inner = self.inner.streams.take().unwrap();
|
||||
let result = f(&mut inner);
|
||||
|
|
@ -325,7 +350,12 @@ impl<T> Clone for StreamCtl<T> {
|
|||
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);
|
||||
log::debug!(
|
||||
"{}: Drop io ({}), {:?}",
|
||||
streams[self.id].context.tag(),
|
||||
self.id,
|
||||
streams[self.id].fd
|
||||
);
|
||||
|
||||
streams[self.id].ref_count -= 1;
|
||||
if streams[self.id].ref_count == 0 {
|
||||
|
|
@ -1,17 +1,17 @@
|
|||
use std::{any, future::poll_fn, io, task::Poll};
|
||||
use std::{any, future::poll_fn, task::Poll};
|
||||
|
||||
use ntex_io::{
|
||||
types, Handle, IoContext, IoStream, ReadContext, ReadStatus, WriteContext, WriteStatus,
|
||||
};
|
||||
use ntex_neon::{net::TcpStream, net::UnixStream, spawn};
|
||||
use ntex_neon::{net::TcpStream, spawn};
|
||||
|
||||
use super::driver::{Closable, CompioOps, StreamCtl};
|
||||
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 = CompioOps::current().register(io, context.clone());
|
||||
let ctl = StreamOps::current().register(io, context.clone());
|
||||
let ctl2 = ctl.clone();
|
||||
spawn(async move { run(ctl, context).await }).detach();
|
||||
|
||||
|
|
@ -23,7 +23,7 @@ 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());
|
||||
let ctl = StreamOps::current().register(io, context.clone());
|
||||
spawn(async move { run(ctl, context).await }).detach();
|
||||
|
||||
None
|
||||
|
|
@ -44,25 +44,13 @@ impl Handle for HandleWrapper {
|
|||
}
|
||||
}
|
||||
|
||||
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) {
|
||||
async fn run<T>(ctl: StreamCtl<T>, context: IoContext) {
|
||||
// Handle io read readiness
|
||||
let st = poll_fn(|cx| {
|
||||
let read = match context.poll_read_ready(cx) {
|
||||
|
|
@ -1,4 +1,3 @@
|
|||
#![allow(clippy::type_complexity)]
|
||||
use std::{io::Result, net, net::SocketAddr};
|
||||
|
||||
use ntex_bytes::PoolRef;
|
||||
|
|
@ -8,10 +7,10 @@ mod connect;
|
|||
mod driver;
|
||||
mod io;
|
||||
|
||||
/// Tcp stream wrapper for compio TcpStream
|
||||
/// Tcp stream wrapper for neon TcpStream
|
||||
struct TcpStream(ntex_neon::net::TcpStream);
|
||||
|
||||
/// Tcp stream wrapper for compio UnixStream
|
||||
/// Tcp stream wrapper for neon UnixStream
|
||||
struct UnixStream(ntex_neon::net::UnixStream);
|
||||
|
||||
/// Opens a TCP connection to a remote host.
|
||||
138
ntex-net/src/rt_uring/connect.rs
Normal file
138
ntex-net/src/rt_uring/connect.rs
Normal file
|
|
@ -0,0 +1,138 @@
|
|||
use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6};
|
||||
use std::{cell::RefCell, io, path::Path, rc::Rc};
|
||||
|
||||
use io_uring::{opcode, types::Fd};
|
||||
use ntex_neon::driver::op::Handler;
|
||||
use ntex_neon::driver::{AsRawFd, DriverApi, RawFd};
|
||||
use ntex_neon::net::{Socket, TcpStream, UnixStream};
|
||||
use ntex_neon::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 ConnectOpsHandler {
|
||||
inner: Rc<ConnectOpsInner>,
|
||||
}
|
||||
|
||||
struct ConnectOpsInner {
|
||||
api: DriverApi,
|
||||
ops: RefCell<Slab<Sender<io::Result<()>>>>,
|
||||
}
|
||||
|
||||
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,
|
||||
ops: RefCell::new(Slab::new()),
|
||||
});
|
||||
inner = Some(ops.clone());
|
||||
Box::new(ConnectOpsHandler { inner: ops })
|
||||
});
|
||||
|
||||
let s = ConnectOps(inner.unwrap());
|
||||
rt.insert(s.clone());
|
||||
s
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
pub(crate) fn connect(
|
||||
&self,
|
||||
fd: RawFd,
|
||||
addr: SockAddr,
|
||||
sender: Sender<io::Result<()>>,
|
||||
) -> usize {
|
||||
let id = self.0.ops.borrow_mut().insert(sender);
|
||||
self.0.api.submit(
|
||||
id as u32,
|
||||
opcode::Connect::new(Fd(fd), addr.as_ptr(), addr.len()).build(),
|
||||
);
|
||||
|
||||
id
|
||||
}
|
||||
}
|
||||
|
||||
impl Handler for ConnectOpsHandler {
|
||||
fn canceled(&mut self, user_data: usize) {
|
||||
log::debug!("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>) {
|
||||
log::debug!("Op is completed {:?} result: {:?}", user_data, result);
|
||||
|
||||
let tx = self.inner.ops.borrow_mut().remove(user_data);
|
||||
let _ = tx.send(result.map(|_| ()));
|
||||
}
|
||||
}
|
||||
419
ntex-net/src/rt_uring/driver.rs
Normal file
419
ntex-net/src/rt_uring/driver.rs
Normal file
|
|
@ -0,0 +1,419 @@
|
|||
use std::{cell::RefCell, fmt, io, mem, num::NonZeroU32, rc::Rc, task::Poll};
|
||||
|
||||
use io_uring::{opcode, squeue::Entry, types::Fd};
|
||||
use ntex_neon::driver::op::Handler;
|
||||
use ntex_neon::driver::{AsRawFd, DriverApi};
|
||||
use ntex_neon::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>>,
|
||||
}
|
||||
|
||||
struct StreamItem<T> {
|
||||
io: Option<T>,
|
||||
fd: Fd,
|
||||
context: IoContext,
|
||||
ref_count: usize,
|
||||
rd_op: Option<NonZeroU32>,
|
||||
wr_op: Option<NonZeroU32>,
|
||||
}
|
||||
|
||||
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: AsRawFd + 'static> StreamOps<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 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 })
|
||||
});
|
||||
|
||||
let s = StreamOps(inner.unwrap());
|
||||
rt.insert(s.clone());
|
||||
s
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
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,
|
||||
};
|
||||
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);
|
||||
}
|
||||
Operation::Send { id, buf, context } => {
|
||||
log::debug!("{}: Send canceled: {:?}", context.tag(), id);
|
||||
context.release_write_buf(buf);
|
||||
}
|
||||
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(),
|
||||
buf,
|
||||
);
|
||||
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
|
||||
if let Some(item) = storage.streams.get_mut(id) {
|
||||
log::debug!(
|
||||
"{}: Send completed: {:?}, res: {:?}",
|
||||
context.tag(),
|
||||
item.fd,
|
||||
result
|
||||
);
|
||||
item.wr_op.take();
|
||||
}
|
||||
|
||||
// set read buf
|
||||
if context
|
||||
.set_write_buf(result.map(|size| size as usize), buf)
|
||||
.is_pending()
|
||||
{
|
||||
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.context.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 ({}), {:?} - {:?} = {:?}",
|
||||
item.context.tag(),
|
||||
id,
|
||||
item.fd,
|
||||
buf,
|
||||
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));
|
||||
}
|
||||
}
|
||||
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 ({}), {:?} {:?}",
|
||||
item.context.tag(),
|
||||
id,
|
||||
item.fd,
|
||||
buf
|
||||
);
|
||||
|
||||
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));
|
||||
}
|
||||
}
|
||||
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 {
|
||||
log::debug!(
|
||||
"{}: Recv to pause ({}), {:?}",
|
||||
item.context.tag(),
|
||||
self.id,
|
||||
item.fd
|
||||
);
|
||||
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.context.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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> PartialEq for StreamCtl<T> {
|
||||
#[inline]
|
||||
fn eq(&self, other: &StreamCtl<T>) -> bool {
|
||||
self.id == other.id && std::ptr::eq(&self.inner, &other.inner)
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: fmt::Debug> fmt::Debug for StreamCtl<T> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
let storage = self.inner.storage.borrow();
|
||||
f.debug_struct("StreamCtl")
|
||||
.field("id", &self.id)
|
||||
.field("io", &storage.streams[self.id].io)
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
95
ntex-net/src/rt_uring/io.rs
Normal file
95
ntex-net/src/rt_uring/io.rs
Normal file
|
|
@ -0,0 +1,95 @@
|
|||
use std::{any, future::poll_fn, task::Poll};
|
||||
|
||||
use ntex_io::{
|
||||
types, Handle, IoContext, IoStream, ReadContext, ReadStatus, WriteContext, WriteStatus,
|
||||
};
|
||||
use ntex_neon::{net::TcpStream, spawn};
|
||||
|
||||
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 }).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 = StreamOps::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
|
||||
}
|
||||
}
|
||||
|
||||
#[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) => {
|
||||
log::debug!("{}: write ready", context.tag());
|
||||
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());
|
||||
}
|
||||
59
ntex-net/src/rt_uring/mod.rs
Normal file
59
ntex-net/src/rt_uring/mod.rs
Normal file
|
|
@ -0,0 +1,59 @@
|
|||
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 neon TcpStream
|
||||
struct TcpStream(ntex_neon::net::TcpStream);
|
||||
|
||||
/// Tcp stream wrapper for neon UnixStream
|
||||
struct UnixStream(ntex_neon::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_neon::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_neon::net::UnixStream::from_std(
|
||||
stream,
|
||||
)?)))
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue