[IN PROGRESS] Update to mio 0.7 and tokio 0.3

mio-udev/Cargo.toml

@@ -13,5 +13,5 @@ edition = "2018"
 
 [dependencies]
 udev = "0.4"
-mio = "0.6"
+mio = { version = "0.7", features = ["os-util"] }
 libc = "0.2"

mio-udev/src/lib.rs

@@ -41,9 +41,9 @@ use std::ffi::OsStr;
 use std::io;
 use std::os::unix::io::{AsRawFd, RawFd};
 
-use mio::event::Evented;
-use mio::unix::EventedFd;
-use mio::{Poll, PollOpt, Ready, Token};
+use mio::event::Source;
+use mio::unix::SourceFd;
+use mio::{Interest, Registry, Token};
 
 /// Monitors for device events.
 ///
@@ -157,29 +157,27 @@ impl MonitorSocket {
     }
 }
 
-impl Evented for MonitorSocket {
+impl Source for MonitorSocket {
     fn register(
-        &self,
-        poll: &Poll,
+        &mut self,
+        registry: &Registry,
         token: Token,
-        interest: Ready,
-        opts: PollOpt,
+        interest: Interest,
     ) -> io::Result<()> {
-        EventedFd(&self.fd()).register(poll, token, interest, opts)
+        SourceFd(&self.fd()).register(registry, token, interest)
     }
 
     fn reregister(
-        &self,
-        poll: &Poll,
+        &mut self,
+        registry: &Registry,
         token: Token,
-        interest: Ready,
-        opts: PollOpt,
+        interest: Interest,
     ) -> io::Result<()> {
-        EventedFd(&self.fd()).reregister(poll, token, interest, opts)
+        SourceFd(&self.fd()).reregister(registry, token, interest)
     }
 
-    fn deregister(&self, poll: &Poll) -> io::Result<()> {
-        EventedFd(&self.fd()).deregister(poll)
+    fn deregister(&mut self, registry: &Registry) -> io::Result<()> {
+        SourceFd(&self.fd()).deregister(registry)
     }
 }
 

tokio-udev/Cargo.toml

@@ -12,7 +12,7 @@ documentation = "https://docs.rs/tokio-udev"
 edition = "2018"
 
 [dependencies]
-mio = "0.6"
+mio = { version = "0.7", features = ["os-poll"] }
 mio-udev = { path = "../mio-udev", version = "0.3.0" }
 
 futures-core = "0.3"

tokio-udev/src/lib.rs

@@ -35,14 +35,14 @@ pub use mio_udev::{
     Property,
 };
 
+use mio::{Events, Interest, Poll as MioPoll, Token};
 use std::ffi::OsStr;
 use std::io;
 use std::pin::Pin;
 use std::sync::Mutex;
 use std::task::Poll;
 
 use futures_core::stream::Stream;
-use tokio::io::PollEvented;
 
 /// Monitors for device events.
 ///
@@ -137,41 +137,40 @@ impl Stream for MonitorSocket {
 
     fn poll_next(
         self: Pin<&mut Self>,
-        cx: &mut std::task::Context,
+        _: &mut std::task::Context,
     ) -> Poll<Option<Self::Item>> {
-        self.inner.lock().unwrap().poll_receive(cx)
+        self.inner.lock().unwrap().poll_receive()
     }
 }
 
 struct Inner {
-    io: PollEvented<mio_udev::MonitorSocket>,
+    poll: MioPoll,
+    monitor: mio_udev::MonitorSocket,
 }
 
 impl Inner {
-    fn new(monitor: mio_udev::MonitorSocket) -> io::Result<Inner> {
-        Ok(Inner {
-            io: PollEvented::new(monitor)?,
-        })
+    fn new(mut monitor: mio_udev::MonitorSocket) -> io::Result<Inner> {
+        let poll = MioPoll::new()?;
+        poll.registry()
+            .register(&mut monitor, Token(0), Interest::READABLE)?;
+        Ok(Inner { poll, monitor })
     }
 
-    fn poll_receive(
-        &mut self,
-        cx: &mut std::task::Context,
-    ) -> Poll<Option<mio_udev::Event>> {
-        if let Poll::Pending =
-            self.io.poll_read_ready(cx, mio::Ready::readable())
-        {
-            return Poll::Pending;
-        }
-
-        match self.io.get_mut().next() {
-            Some(event) => Poll::Ready(Some(event)),
-            None => {
-                self.io
-                    .clear_read_ready(cx, mio::Ready::readable())
-                    .unwrap();
-                Poll::Pending
+    fn poll_receive(&mut self) -> Poll<Option<mio_udev::Event>> {
+        let mut events = Events::with_capacity(1);
+        self.poll.poll(&mut events, None).unwrap();
+        let mut events = events.into_iter();
+        match events.next() {
+            Some(event) => {
+                if event.is_error() {
+                    Poll::Ready(None)
+                } else if !event.is_readable() {
+                    Poll::Pending
+                } else {
+                    Poll::Ready(self.monitor.next())
+                }
             }
+            None => Poll::Pending,
         }
     }
 }