Merge pull request #5 from stepfunc/feature/tokio-1.0

jadamcrain · web-flow · commit 164c00f15e0a · 2021-03-10T15:48:46.000-08:00
Feature/tokio 1.0
diff --git a/Cargo.toml b/Cargo.toml
@@ -5,4 +5,4 @@ authors = ["Émile Grégoire <emile@stepfunc.io>"]
 edition = "2018"
 
 [dependencies]
-tokio = { version = "^0.2.23", features = ["tcp", "dns", "sync", "io-util", "io-std", "time", "rt-core", "rt-threaded", "macros"] }
+tokio = { version = "1", features = ["net", "sync", "io-util", "io-std", "time", "rt", "rt-multi-thread", "macros"] }
diff --git a/src/mock/mod.rs b/src/mock/mod.rs
@@ -53,7 +53,7 @@ mod tests {
     fn select_task(mut rx: sync::mpsc::Receiver<u32>) -> Spawn<impl Future<Output = Option<u32>>> {
         crate::mock::test::spawn(async move {
             tokio::select! {
-                _ = time::delay_for(Duration::from_secs(1)) => {
+                _ = time::sleep(Duration::from_secs(1)) => {
                     None
                 }
                 value = rx.recv() => {
diff --git a/src/mock/sync/mpsc.rs b/src/mock/sync/mpsc.rs
@@ -5,7 +5,7 @@ use std::pin::Pin;
 use std::sync::{Arc, Mutex};
 use std::task::{Context, Poll};
 
-use tokio::sync::mpsc::error::{SendError, TryRecvError, TrySendError};
+use tokio::sync::mpsc::error::{SendError, TrySendError};
 
 pub use tokio::sync::mpsc::error;
 
@@ -27,13 +27,13 @@ impl<T> ChannelData<T> {
         }
     }
 
-    fn try_recv(&mut self) -> Result<T, TryRecvError> {
+    fn poll_recv(&mut self) -> Poll<Option<T>> {
         if let Some(msg) = self.queue.pop_front() {
-            Ok(msg)
+            Poll::Ready(Some(msg))
         } else if self.num_senders == 0 {
-            Err(TryRecvError::Closed)
+            Poll::Ready(None)
         } else {
-            Err(TryRecvError::Empty)
+            Poll::Pending
         }
     }
 
@@ -62,11 +62,7 @@ impl<T> Future for ReceiveFuture<T> {
     type Output = Option<T>;
 
     fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
-        match self.data.lock().unwrap().try_recv() {
-            Ok(msg) => Poll::Ready(Some(msg)),
-            Err(TryRecvError::Closed) => Poll::Ready(None),
-            Err(TryRecvError::Empty) => Poll::Pending,
-        }
+        self.data.lock().unwrap().poll_recv()
     }
 }
 
@@ -110,8 +106,8 @@ impl<T> Receiver<T> {
         }
     }
 
-    pub fn try_recv(&mut self) -> Result<T, TryRecvError> {
-        self.data.lock().unwrap().try_recv()
+    pub fn poll_recv(&mut self) -> Poll<Option<T>> {
+        self.data.lock().unwrap().poll_recv()
     }
 
     pub fn close(&mut self) {
@@ -279,14 +275,14 @@ mod tests {
         fn dropping_tx_try_recv() {
             let (mut tx, mut rx) = channel(16);
 
-            assert_eq!(rx.try_recv(), Err(TryRecvError::Empty));
+            assert_eq!(rx.poll_recv(), Poll::Pending);
             assert_ready!(spawn(async move {
                 tx.send(()).await.unwrap();
                 drop(tx);
             })
             .poll());
-            assert_eq!(rx.try_recv(), Ok(()));
-            assert_eq!(rx.try_recv(), Err(TryRecvError::Closed));
+            assert_eq!(rx.poll_recv(), Poll::Ready(Some(())));
+            assert_eq!(rx.poll_recv(), Poll::Ready(None));
         }
 
         #[test]
@@ -346,7 +342,7 @@ mod tests {
                 assert!(tx.try_send(()).is_ok());
             }
             assert!(matches!(tx.try_send(()), Err(TrySendError::Full(()))));
-            assert!(rx.try_recv().is_ok());
+            assert_eq!(rx.poll_recv(), Poll::Ready(Some(())));
             assert!(tx.try_send(()).is_ok());
         }
     }
@@ -370,11 +366,11 @@ mod tests {
         fn dropping_tx_try_recv() {
             let (mut tx, mut rx) = unbounded_channel();
 
-            assert_eq!(rx.try_recv(), Err(TryRecvError::Empty));
+            assert_eq!(rx.poll_recv(), Poll::Pending);
             tx.send(()).unwrap();
             drop(tx);
-            assert_eq!(rx.try_recv(), Ok(()));
-            assert_eq!(rx.try_recv(), Err(TryRecvError::Closed));
+            assert_eq!(rx.poll_recv(), Poll::Ready(Some(())));
+            assert_eq!(rx.poll_recv(), Poll::Ready(None));
         }
 
         #[test]
diff --git a/src/mock/test/io.rs b/src/mock/test/io.rs
@@ -3,9 +3,11 @@ use std::collections::VecDeque;
 use std::pin::Pin;
 use std::sync::{Arc, Mutex};
 use std::task::{Context, Poll};
+use tokio::io::ReadBuf;
 
+#[derive(Debug)]
 enum ChannelState {
-    Open(VecDeque<u8>),
+    Open(VecDeque<Box<[u8]>>),
     Closed,
     Error(ErrorKind),
 }
@@ -17,9 +19,12 @@ impl ChannelState {
 
     fn push(&mut self, data: &[u8]) {
         match self {
-            Self::Open(buffer) => buffer.extend(data.iter()),
+            Self::Open(buffer) => {
+                buffer.push_back(Vec::from(data).into_boxed_slice());
+            }
             _ => {
-                let buffer = data.iter().copied().collect();
+                let mut buffer = VecDeque::new();
+                buffer.push_back(Vec::from(data).into_boxed_slice());
                 *self = Self::Open(buffer);
             }
         }
@@ -41,6 +46,7 @@ impl ChannelState {
     }
 }
 
+#[derive(Debug)]
 struct Shared {
     write_pending: bool,
     write_channel: ChannelState,
@@ -110,33 +116,31 @@ impl Drop for Handle {
     }
 }
 
+#[derive(Debug)]
 pub struct MockIO(Arc<Mutex<Shared>>);
 
 impl AsyncRead for MockIO {
     fn poll_read(
         self: Pin<&mut Self>,
         _cx: &mut Context<'_>,
-        buf: &mut [u8],
-    ) -> Poll<std::io::Result<usize>> {
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<std::io::Result<()>> {
         let mut shared = self.0.lock().unwrap();
 
         match &mut shared.read_channel {
-            ChannelState::Open(data) => match data.len() {
-                0 => Poll::Pending,
-                _ => {
-                    let mut num_bytes = 0;
-                    for dest in buf.iter_mut() {
-                        if let Some(byte) = data.pop_front() {
-                            *dest = byte;
-                            num_bytes += 1;
-                        } else {
-                            return Poll::Ready(Ok(num_bytes));
+            ChannelState::Open(data) => {
+                match data.pop_front() {
+                    None => Poll::Pending,
+                    Some(bytes) => {
+                        if bytes.len() > buf.remaining() {
+                            panic!("insufficient write space (available == {}) for queued read (len = {})", buf.remaining(), bytes.len());
                         }
+                        buf.put_slice(&bytes);
+                        Poll::Ready(Ok(()))
                     }
-                    Poll::Ready(Ok(num_bytes))
                 }
-            },
-            ChannelState::Closed => Poll::Ready(Ok(0)),
+            }
+            ChannelState::Closed => Poll::Ready(Ok(())),
             ChannelState::Error(err) => Poll::Ready(Err(Error::new(*err, "test error"))),
         }
     }
@@ -151,33 +155,22 @@ impl AsyncWrite for MockIO {
         let mut shared = self.0.lock().unwrap();
 
         match &mut shared.write_channel {
-            ChannelState::Open(data) => match data.len() {
-                0 => {
+            ChannelState::Open(data) => match data.pop_front() {
+                None => {
                     shared.write_pending = true;
                     Poll::Pending
                 }
-                _ => {
-                    let copy = data.clone();
-
-                    let mut num_bytes = 0;
-                    for dest in buf.iter() {
-                        if let Some(byte) = data.pop_front() {
-                            if *dest != byte {
-                                panic!(
-                                    r#"unexpected write: 
+                Some(expected) => {
+                    if buf != expected.as_ref() {
+                        panic!(
+                            r#"unexpected write:
  expected: {:02X?},
  received: {:02X?}"#,
-                                    copy, buf
-                                );
-                            }
-                            num_bytes += 1;
-                        } else {
-                            shared.write_pending = true;
-                            return Poll::Ready(Ok(num_bytes));
-                        }
+                            expected, buf
+                        );
                     }
                     shared.write_pending = false;
-                    Poll::Ready(Ok(num_bytes))
+                    Poll::Ready(Ok(expected.len()))
                 }
             },
             ChannelState::Closed => Poll::Ready(Ok(0)),
diff --git a/src/mock/time/mod.rs b/src/mock/time/mod.rs
@@ -1,17 +1,17 @@
 mod clock;
-mod delay;
 mod instant;
+mod sleep;
 
 pub use std::time::Duration;
 
-pub use delay::Delay;
 pub use instant::Instant;
+pub use sleep::Delay;
 
-pub fn delay_until(deadline: Instant) -> Delay {
+pub fn sleep_until(deadline: Instant) -> Delay {
     Delay::new_deadline(deadline)
 }
 
-pub fn delay_for(delay: Duration) -> Delay {
+pub fn sleep(delay: Duration) -> Delay {
     Delay::new_delay(delay)
 }
 
diff --git a/src/mock/time/sleep.rs b/src/mock/time/sleep.rs
diff --git a/src/real.rs b/src/real.rs
@@ -22,8 +22,8 @@ pub mod time {
 
     pub use std::time::Duration; // Re-export in tokio
 
-    pub use time::delay_for;
-    pub use time::delay_until;
+    pub use time::sleep;
+    pub use time::sleep_until;
     pub use time::Instant;
 }
 
@@ -42,8 +42,8 @@ pub mod sync {
         pub mod error {
             use tokio::sync::mpsc::error;
 
+            pub use error::RecvError;
             pub use error::SendError;
-            pub use error::TryRecvError;
             pub use error::TrySendError;
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ mod tests {`
`53`	`53`	`fn select_task(mut rx: sync::mpsc::Receiver<u32>) -> Spawn<impl Future<Output = Option<u32>>> {`
`54`	`54`	`crate::mock::test::spawn(async move {`
`55`	`55`	`tokio::select! {`
`56`		`- _ = time::delay_for(Duration::from_secs(1)) => {`
	`56`	`+ _ = time::sleep(Duration::from_secs(1)) => {`
`57`	`57`	`None`
`58`	`58`	`}`
`59`	`59`	`value = rx.recv() => {`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ use std::pin::Pin;`
`5`	`5`	`use std::sync::{Arc, Mutex};`
`6`	`6`	`use std::task::{Context, Poll};`
`7`	`7`
`8`		`-use tokio::sync::mpsc::error::{SendError, TryRecvError, TrySendError};`
	`8`	`+use tokio::sync::mpsc::error::{SendError, TrySendError};`
`9`	`9`
`10`	`10`	`pub use tokio::sync::mpsc::error;`
`11`	`11`
`@@ -27,13 +27,13 @@ impl<T> ChannelData<T> {`
`27`	`27`	`}`
`28`	`28`	`}`
`29`	`29`
`30`		`- fn try_recv(&mut self) -> Result<T, TryRecvError> {`
	`30`	`+ fn poll_recv(&mut self) -> Poll<Option<T>> {`
`31`	`31`	`if let Some(msg) = self.queue.pop_front() {`
`32`		`- Ok(msg)`
	`32`	`+ Poll::Ready(Some(msg))`
`33`	`33`	`} else if self.num_senders == 0 {`
`34`		`- Err(TryRecvError::Closed)`
	`34`	`+ Poll::Ready(None)`
`35`	`35`	`} else {`
`36`		`- Err(TryRecvError::Empty)`
	`36`	`+ Poll::Pending`
`37`	`37`	`}`
`38`	`38`	`}`
`39`	`39`
`@@ -62,11 +62,7 @@ impl<T> Future for ReceiveFuture<T> {`
`62`	`62`	`type Output = Option<T>;`
`63`	`63`
`64`	`64`	`fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {`
`65`		`- match self.data.lock().unwrap().try_recv() {`
`66`		`- Ok(msg) => Poll::Ready(Some(msg)),`
`67`		`- Err(TryRecvError::Closed) => Poll::Ready(None),`
`68`		`- Err(TryRecvError::Empty) => Poll::Pending,`
`69`		`- }`
	`65`	`+ self.data.lock().unwrap().poll_recv()`
`70`	`66`	`}`
`71`	`67`	`}`
`72`	`68`
`@@ -110,8 +106,8 @@ impl<T> Receiver<T> {`
`110`	`106`	`}`
`111`	`107`	`}`
`112`	`108`
`113`		`- pub fn try_recv(&mut self) -> Result<T, TryRecvError> {`
`114`		`- self.data.lock().unwrap().try_recv()`
	`109`	`+ pub fn poll_recv(&mut self) -> Poll<Option<T>> {`
	`110`	`+ self.data.lock().unwrap().poll_recv()`
`115`	`111`	`}`
`116`	`112`
`117`	`113`	`pub fn close(&mut self) {`
`@@ -279,14 +275,14 @@ mod tests {`
`279`	`275`	`fn dropping_tx_try_recv() {`
`280`	`276`	`let (mut tx, mut rx) = channel(16);`
`281`	`277`
`282`		`- assert_eq!(rx.try_recv(), Err(TryRecvError::Empty));`
	`278`	`+ assert_eq!(rx.poll_recv(), Poll::Pending);`
`283`	`279`	`assert_ready!(spawn(async move {`
`284`	`280`	`tx.send(()).await.unwrap();`
`285`	`281`	`drop(tx);`
`286`	`282`	`})`
`287`	`283`	`.poll());`
`288`		`- assert_eq!(rx.try_recv(), Ok(()));`
`289`		`- assert_eq!(rx.try_recv(), Err(TryRecvError::Closed));`
	`284`	`+ assert_eq!(rx.poll_recv(), Poll::Ready(Some(())));`
	`285`	`+ assert_eq!(rx.poll_recv(), Poll::Ready(None));`
`290`	`286`	`}`
`291`	`287`
`292`	`288`	`#[test]`
`@@ -346,7 +342,7 @@ mod tests {`
`346`	`342`	`assert!(tx.try_send(()).is_ok());`
`347`	`343`	`}`
`348`	`344`	`assert!(matches!(tx.try_send(()), Err(TrySendError::Full(()))));`
`349`		`- assert!(rx.try_recv().is_ok());`
	`345`	`+ assert_eq!(rx.poll_recv(), Poll::Ready(Some(())));`
`350`	`346`	`assert!(tx.try_send(()).is_ok());`
`351`	`347`	`}`
`352`	`348`	`}`
`@@ -370,11 +366,11 @@ mod tests {`
`370`	`366`	`fn dropping_tx_try_recv() {`
`371`	`367`	`let (mut tx, mut rx) = unbounded_channel();`
`372`	`368`
`373`		`- assert_eq!(rx.try_recv(), Err(TryRecvError::Empty));`
	`369`	`+ assert_eq!(rx.poll_recv(), Poll::Pending);`
`374`	`370`	`tx.send(()).unwrap();`
`375`	`371`	`drop(tx);`
`376`		`- assert_eq!(rx.try_recv(), Ok(()));`
`377`		`- assert_eq!(rx.try_recv(), Err(TryRecvError::Closed));`
	`372`	`+ assert_eq!(rx.poll_recv(), Poll::Ready(Some(())));`
	`373`	`+ assert_eq!(rx.poll_recv(), Poll::Ready(None));`
`378`	`374`	`}`
`379`	`375`
`380`	`376`	`#[test]`
Original file line number	Diff line number	Diff line change
`@@ -22,8 +22,8 @@ pub mod time {`
`22`	`22`
`23`	`23`	`pub use std::time::Duration; // Re-export in tokio`
`24`	`24`
`25`		`- pub use time::delay_for;`
`26`		`- pub use time::delay_until;`
	`25`	`+ pub use time::sleep;`
	`26`	`+ pub use time::sleep_until;`
`27`	`27`	`pub use time::Instant;`
`28`	`28`	`}`
`29`	`29`
`@@ -42,8 +42,8 @@ pub mod sync {`
`42`	`42`	`pub mod error {`
`43`	`43`	`use tokio::sync::mpsc::error;`
`44`	`44`
	`45`	`+ pub use error::RecvError;`
`45`	`46`	`pub use error::SendError;`
`46`		`- pub use error::TryRecvError;`
`47`	`47`	`pub use error::TrySendError;`
`48`	`48`	`}`
`49`	`49`	`}`