Skip to content

Commit 1308fbd

Browse files
dignifiedquiredignifiedquire
committed
switch to smol instead of an internal runtime
1 parent 690ab16 commit 1308fbd

File tree

20 files changed

+210
-1380
lines changed

20 files changed

+210
-1380
lines changed

‎Cargo.toml‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -48,6 +48,7 @@ std = [
4848
"once_cell",
4949
"pin-utils",
5050
"slab",
51+
"piper",
5152
]
5253
alloc = [
5354
"futures-core/alloc",
@@ -76,6 +77,7 @@ pin-project-lite = { version = "0.1.4", optional = true }
7677
pin-utils = { version = "0.1.0-alpha.4", optional = true }
7778
slab = { version = "0.4.2", optional = true }
7879
smol = { path = "../smol", optional = true }
80+
piper = { git = "https://github.com/stjepang/piper.git", branch = "master", optional = true }
7981

8082
[dev-dependencies]
8183
femme = "1.3.0"

‎src/net/tcp/listener.rs‎

Lines changed: 30 additions & 37 deletions
Original file line numberDiff line numberDiff line change
@@ -1,13 +1,13 @@
11
use std::future::Future;
22
use std::net::SocketAddr;
33
use std::pin::Pin;
4-
use std::sync::Arc;
54

6-
use crate::future;
5+
use smol::Async;
6+
77
use crate::io;
8-
use crate::rt::Watcher;
98
use crate::net::{TcpStream, ToSocketAddrs};
109
use crate::stream::Stream;
10+
use crate::sync::Arc;
1111
use crate::task::{Context, Poll};
1212

1313
/// A TCP socket server, listening for connections.
@@ -49,7 +49,7 @@ use crate::task::{Context, Poll};
4949
/// ```
5050
#[derive(Debug)]
5151
pub struct TcpListener {
52-
watcher: Watcher<mio::net::TcpListener>,
52+
watcher: Async<std::net::TcpListener>,
5353
}
5454

5555
impl TcpListener {
@@ -79,11 +79,9 @@ impl TcpListener {
7979
let addrs = addrs.to_socket_addrs().await?;
8080

8181
for addr in addrs {
82-
match mio::net::TcpListener::bind(&addr) {
83-
Ok(mio_listener) => {
84-
return Ok(TcpListener {
85-
watcher: Watcher::new(mio_listener),
86-
});
82+
match Async::<std::net::TcpListener>::bind(&addr) {
83+
Ok(listener) => {
84+
return Ok(TcpListener { watcher: listener });
8785
}
8886
Err(err) => last_err = Some(err),
8987
}
@@ -114,13 +112,9 @@ impl TcpListener {
114112
/// # Ok(()) }) }
115113
/// ```
116114
pub async fn accept(&self) -> io::Result<(TcpStream, SocketAddr)> {
117-
let (io, addr) =
118-
future::poll_fn(|cx| self.watcher.poll_read_with(cx, |inner| inner.accept_std()))
119-
.await?;
120-
121-
let mio_stream = mio::net::TcpStream::from_stream(io)?;
115+
let (stream, addr) = self.watcher.accept().await?;
122116
let stream = TcpStream {
123-
watcher: Arc::new(Watcher::new(mio_stream)),
117+
watcher: Arc::new(stream),
124118
};
125119
Ok((stream, addr))
126120
}
@@ -206,9 +200,8 @@ impl<'a> Stream for Incoming<'a> {
206200
impl From<std::net::TcpListener> for TcpListener {
207201
/// Converts a `std::net::TcpListener` into its asynchronous equivalent.
208202
fn from(listener: std::net::TcpListener) -> TcpListener {
209-
let mio_listener = mio::net::TcpListener::from_std(listener).unwrap();
210203
TcpListener {
211-
watcher: Watcher::new(mio_listener),
204+
watcher: Async::new(listener).expect("TcpListener is known to be good"),
212205
}
213206
}
214207
}
@@ -230,29 +223,29 @@ cfg_unix! {
230223

231224
impl IntoRawFd for TcpListener {
232225
fn into_raw_fd(self) -> RawFd {
233-
self.watcher.into_inner().into_raw_fd()
226+
self.watcher.into_raw_fd()
234227
}
235228
}
236229
}
237230

238231
cfg_windows! {
239-
// use crate::os::windows::io::{AsRawHandle, FromRawHandle, IntoRawHandle, RawHandle};
240-
//
241-
// impl AsRawSocket for TcpListener {
242-
// fn as_raw_socket(&self) -> RawSocket {
243-
// self.raw_socket
244-
// }
245-
// }
246-
//
247-
// impl FromRawSocket for TcpListener {
248-
// unsafe fn from_raw_socket(handle: RawSocket) -> TcpListener {
249-
// net::TcpListener::from_raw_socket(handle).try_into().unwrap()
250-
// }
251-
// }
252-
//
253-
// impl IntoRawSocket for TcpListener {
254-
// fn into_raw_socket(self) -> RawSocket {
255-
// self.raw_socket
256-
// }
257-
// }
232+
use crate::os::windows::io::{AsRawHandle, FromRawHandle, IntoRawHandle, RawHandle};
233+
234+
impl AsRawSocket for TcpListener {
235+
fn as_raw_socket(&self) -> RawSocket {
236+
self.watcher.as_raw_socket()
237+
}
238+
}
239+
240+
impl FromRawSocket for TcpListener {
241+
unsafe fn from_raw_socket(handle: RawSocket) -> TcpListener {
242+
net::TcpListener::from_raw_socket(handle).try_into().unwrap()
243+
}
244+
}
245+
246+
impl IntoRawSocket for TcpListener {
247+
fn into_raw_socket(self) -> RawSocket {
248+
self.watcher.into_raw_socket()
249+
}
250+
}
258251
}

‎src/net/tcp/stream.rs‎

Lines changed: 37 additions & 52 deletions
Original file line numberDiff line numberDiff line change
@@ -1,12 +1,12 @@
1-
use std::io::{IoSlice, IoSliceMut, Read as _, Write as _};
1+
use std::io::{IoSlice, IoSliceMut};
22
use std::net::SocketAddr;
33
use std::pin::Pin;
4-
use std::sync::Arc;
54

6-
use crate::future;
5+
use smol::Async;
6+
77
use crate::io::{self, Read, Write};
8-
use crate::rt::Watcher;
98
use crate::net::ToSocketAddrs;
9+
use crate::sync::Arc;
1010
use crate::task::{Context, Poll};
1111

1212
/// A TCP stream between a local and a remote socket.
@@ -47,7 +47,7 @@ use crate::task::{Context, Poll};
4747
/// ```
4848
#[derive(Debug, Clone)]
4949
pub struct TcpStream {
50-
pub(super) watcher: Arc<Watcher<mio::net::TcpStream>>,
50+
pub(super) watcher: Arc<Async<std::net::TcpStream>>,
5151
}
5252

5353
impl TcpStream {
@@ -75,28 +75,16 @@ impl TcpStream {
7575
let addrs = addrs.to_socket_addrs().await?;
7676

7777
for addr in addrs {
78-
// mio's TcpStream::connect is non-blocking and may just be in progress
79-
// when it returns with `Ok`. We therefore wait for write readiness to
80-
// be sure the connection has either been established or there was an
81-
// error which we check for afterwards.
82-
let watcher = match mio::net::TcpStream::connect(&addr) {
83-
Ok(s) => Watcher::new(s),
78+
match Async::<std::net::TcpStream>::connect(&addr).await {
79+
Ok(stream) => {
80+
return Ok(TcpStream {
81+
watcher: Arc::new(stream),
82+
});
83+
}
8484
Err(e) => {
8585
last_err = Some(e);
8686
continue;
8787
}
88-
};
89-
90-
future::poll_fn(|cx| watcher.poll_write_ready(cx)).await;
91-
92-
match watcher.get_ref().take_error() {
93-
Ok(None) => {
94-
return Ok(TcpStream {
95-
watcher: Arc::new(watcher),
96-
});
97-
}
98-
Ok(Some(e)) => last_err = Some(e),
99-
Err(e) => last_err = Some(e),
10088
}
10189
}
10290

@@ -214,7 +202,7 @@ impl TcpStream {
214202
/// # Ok(()) }) }
215203
/// ```
216204
pub async fn peek(&self, buf: &mut [u8]) -> io::Result<usize> {
217-
future::poll_fn(|cx| self.watcher.poll_read_with(cx, |inner| inner.peek(buf))).await
205+
self.watcher.peek(buf).await
218206
}
219207

220208
/// Gets the value of the `TCP_NODELAY` option on this socket.
@@ -317,7 +305,7 @@ impl Read for &TcpStream {
317305
cx: &mut Context<'_>,
318306
buf: &mut [u8],
319307
) -> Poll<io::Result<usize>> {
320-
self.watcher.poll_read_with(cx, |mut inner| inner.read(buf))
308+
Pin::new(&mut &*self.watcher).poll_read(cx, buf)
321309
}
322310
}
323311

@@ -353,26 +341,23 @@ impl Write for &TcpStream {
353341
cx: &mut Context<'_>,
354342
buf: &[u8],
355343
) -> Poll<io::Result<usize>> {
356-
self.watcher
357-
.poll_write_with(cx, |mut inner| inner.write(buf))
344+
Pin::new(&mut &*self.watcher).poll_write(cx, buf)
358345
}
359346

360347
fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
361-
self.watcher.poll_write_with(cx, |mut inner| inner.flush())
348+
Pin::new(&mut &*self.watcher).poll_flush(cx)
362349
}
363350

364-
fn poll_close(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::Result<()>> {
365-
self.shutdown(std::net::Shutdown::Write)?;
366-
Poll::Ready(Ok(()))
351+
fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
352+
Pin::new(&mut &*self.watcher).poll_close(cx)
367353
}
368354
}
369355

370356
impl From<std::net::TcpStream> for TcpStream {
371357
/// Converts a `std::net::TcpStream` into its asynchronous equivalent.
372358
fn from(stream: std::net::TcpStream) -> TcpStream {
373-
let mio_stream = mio::net::TcpStream::from_stream(stream).unwrap();
374359
TcpStream {
375-
watcher: Arc::new(Watcher::new(mio_stream)),
360+
watcher: Arc::new(Async::new(stream).expect("TcpStream is known to be good")),
376361
}
377362
}
378363
}
@@ -403,23 +388,23 @@ cfg_unix! {
403388
}
404389

405390
cfg_windows! {
406-
// use crate::os::windows::io::{AsRawHandle, FromRawHandle, IntoRawHandle, RawHandle};
407-
//
408-
// impl AsRawSocket for TcpStream {
409-
// fn as_raw_socket(&self) -> RawSocket {
410-
// self.raw_socket
411-
// }
412-
// }
413-
//
414-
// impl FromRawSocket for TcpStream {
415-
// unsafe fn from_raw_socket(handle: RawSocket) -> TcpStream {
416-
// net::TcpStream::from_raw_socket(handle).try_into().unwrap()
417-
// }
418-
// }
419-
//
420-
// impl IntoRawSocket for TcpListener {
421-
// fn into_raw_socket(self) -> RawSocket {
422-
// self.raw_socket
423-
// }
424-
// }
391+
use crate::os::windows::io::{AsRawHandle, FromRawHandle, IntoRawHandle, RawHandle};
392+
393+
impl AsRawSocket for TcpStream {
394+
fn as_raw_socket(&self) -> RawSocket {
395+
self.raw_socket
396+
}
397+
}
398+
399+
impl FromRawSocket for TcpStream {
400+
unsafe fn from_raw_socket(handle: RawSocket) -> TcpStream {
401+
net::TcpStream::from_raw_socket(handle).try_into().unwrap()
402+
}
403+
}
404+
405+
impl IntoRawSocket for TcpListener {
406+
fn into_raw_socket(self) -> RawSocket {
407+
self.raw_socket
408+
}
409+
}
425410
}

0 commit comments

Comments
 (0)