Merge pull request #20 from scontain/updated-deps

refactor!: upgrade deps and fix compile errors

Author: jcreekmore

Cargo.toml

@@ -20,7 +20,7 @@ version = "0.3.4-alpha.0"
 repository = "jcreekmore/timeout-readwrite-rs"
 
 [dependencies]
-nix = { version = "0.26.0", default-features = false, features = ["poll"] }
+nix = { version = "0.29.0", default-features = false, features = ["poll"] }
 
 [dev-dependencies]
-lazy_static = "1.3.0"
+lazy_static = "1.5.0"

src/reader.rs

@@ -12,7 +12,7 @@ use std::io::Read;
 use std::io::Result;
 use std::io::Seek;
 use std::io::SeekFrom;
-use std::os::unix::io::AsRawFd;
+use std::os::fd::AsFd;
 use std::time::Duration;
 
 use super::utils;
@@ -29,15 +29,15 @@ use super::utils;
 /// of the `Read` trait could also be produced by the `TimeoutReader`.
 pub struct TimeoutReader<H>
 where
-    H: Read + AsRawFd,
+    H: Read + AsFd,
 {
     timeout: Option<c_int>,
     handle: H,
 }
 
 impl<H> Read for TimeoutReader<H>
 where
-    H: Read + AsRawFd,
+    H: Read + AsFd,
 {
     fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
         utils::wait_until_ready(self.timeout, &self.handle, PollFlags::POLLIN)?;
@@ -47,25 +47,25 @@ where
 
 impl<H> Seek for TimeoutReader<H>
 where
-    H: Read + AsRawFd + Seek,
+    H: Read + AsFd + Seek,
 {
     fn seek(&mut self, pos: SeekFrom) -> Result<u64> {
         self.handle.seek(pos)
     }
 }
 
-impl<H> AsRawFd for TimeoutReader<H>
+impl<H> AsFd for TimeoutReader<H>
 where
-    H: Read + AsRawFd,
+    H: Read + AsFd,
 {
-    fn as_raw_fd(&self) -> c_int {
-        self.handle.as_raw_fd()
+    fn as_fd(&self) -> std::os::unix::prelude::BorrowedFd<'_> {
+        self.handle.as_fd()
     }
 }
 
 impl<H> Clone for TimeoutReader<H>
 where
-    H: Read + AsRawFd + Clone,
+    H: Read + AsFd + Clone,
 {
     fn clone(&self) -> TimeoutReader<H> {
         TimeoutReader {
@@ -77,7 +77,7 @@ where
 
 impl<H> TimeoutReader<H>
 where
-    H: Read + AsRawFd,
+    H: Read + AsFd,
 {
     /// Create a new `TimeoutReader` with an optional timeout.
     ///
@@ -113,21 +113,21 @@ where
     pub fn new<T: Into<Option<Duration>>>(handle: H, timeout: T) -> TimeoutReader<H> {
         TimeoutReader {
             timeout: timeout.into().map(utils::duration_to_ms),
-            handle: handle,
+            handle,
         }
     }
 }
 
 pub trait TimeoutReadExt<H>
 where
-    H: Read + AsRawFd,
+    H: Read + AsFd,
 {
     fn with_timeout<T: Into<Option<Duration>>>(self, timeout: T) -> TimeoutReader<H>;
 }
 
 impl<H> TimeoutReadExt<H> for H
 where
-    H: Read + AsRawFd,
+    H: Read + AsFd,
 {
     fn with_timeout<T: Into<Option<Duration>>>(self, timeout: T) -> TimeoutReader<H> {
         TimeoutReader::new(self, timeout)
@@ -139,6 +139,7 @@ mod tests {
     use std::env;
     use std::fs::File;
     use std::io::Read;
+    use std::os::fd::AsRawFd;
     use std::path::PathBuf;
     use std::time::Duration;
 
@@ -177,7 +178,7 @@ mod tests {
 
         assert_eq!(original_contents, read_contents);
 
-        assert_eq!(fp_fd, fp.as_raw_fd());
+        assert_eq!(fp_fd, fp.as_fd().as_raw_fd());
     }
 
     #[test]

src/utils.rs

@@ -9,33 +9,37 @@
 use nix::libc::c_int;
 use nix::poll;
 use std::cmp;
+use std::convert::TryFrom;
 use std::io::{Error, ErrorKind, Result};
-use std::os::unix::io::AsRawFd;
+use std::os::fd::AsFd;
 use std::slice;
 use std::time::Duration;
 
 /// Convert from a duration into milliseconds as the c_int type that poll expects.
 /// If the duration exceeds the number of milliseconds that can fit into a c_int,
 /// saturate the time to the max_value of c_int.
 pub fn duration_to_ms(duration: Duration) -> c_int {
-    let secs = cmp::min(duration.as_secs(), c_int::max_value() as u64) as c_int;
+    let secs = cmp::min(duration.as_secs(), c_int::MAX as u64) as c_int;
     let nanos = duration.subsec_nanos() as c_int;
 
     secs.saturating_mul(1_000).saturating_add(nanos / 1_000_000)
 }
 
 /// Wait until `to_fd` receives the poll event from `events`, up to `timeout` length
 /// of time.
-pub fn wait_until_ready<R: AsRawFd>(
+pub fn wait_until_ready(
     timeout: Option<c_int>,
-    to_fd: &R,
+    fd: &impl AsFd,
     events: poll::PollFlags,
 ) -> Result<()> {
     if let Some(timeout) = timeout {
-        let mut pfd = poll::PollFd::new(to_fd.as_raw_fd(), events);
-        let mut s = unsafe { slice::from_raw_parts_mut(&mut pfd, 1) };
+        let mut pfd = poll::PollFd::new(fd.as_fd(), events);
+        let s = slice::from_mut(&mut pfd);
 
-        let retval = poll::poll(&mut s, timeout).map_err(|e| Error::new(ErrorKind::Other, e))?;
+        let timeout =
+            poll::PollTimeout::try_from(timeout).map_err(|e| Error::new(ErrorKind::Other, e))?;
+
+        let retval = poll::poll(s, timeout).map_err(|e| Error::new(ErrorKind::Other, e))?;
         if retval == 0 {
             return Err(Error::new(
                 ErrorKind::TimedOut,

src/writer.rs

@@ -12,7 +12,8 @@ use std::io::Result;
 use std::io::Seek;
 use std::io::SeekFrom;
 use std::io::Write;
-use std::os::unix::io::AsRawFd;
+use std::os::fd::AsFd;
+use std::os::fd::BorrowedFd;
 use std::time::Duration;
 
 use super::utils;
@@ -29,15 +30,15 @@ use super::utils;
 /// of the `Write` trait could also be produced by the `TimeoutWriter`.
 pub struct TimeoutWriter<H>
 where
-    H: Write + AsRawFd,
+    H: Write + AsFd,
 {
     timeout: Option<c_int>,
     handle: H,
 }
 
 impl<H> Write for TimeoutWriter<H>
 where
-    H: Write + AsRawFd,
+    H: Write + AsFd,
 {
     fn write(&mut self, buf: &[u8]) -> Result<usize> {
         utils::wait_until_ready(self.timeout, &self.handle, PollFlags::POLLOUT)?;
@@ -52,25 +53,25 @@ where
 
 impl<H> Seek for TimeoutWriter<H>
 where
-    H: Write + AsRawFd + Seek,
+    H: Write + AsFd + Seek,
 {
     fn seek(&mut self, pos: SeekFrom) -> Result<u64> {
         self.handle.seek(pos)
     }
 }
 
-impl<H> AsRawFd for TimeoutWriter<H>
+impl<H> AsFd for TimeoutWriter<H>
 where
-    H: Write + AsRawFd,
+    H: Write + AsFd,
 {
-    fn as_raw_fd(&self) -> c_int {
-        self.handle.as_raw_fd()
+    fn as_fd(&self) -> BorrowedFd<'_> {
+        self.handle.as_fd()
     }
 }
 
 impl<H> Clone for TimeoutWriter<H>
 where
-    H: Write + AsRawFd + Clone,
+    H: Write + AsFd + Clone,
 {
     fn clone(&self) -> TimeoutWriter<H> {
         TimeoutWriter {
@@ -82,7 +83,7 @@ where
 
 impl<H> TimeoutWriter<H>
 where
-    H: Write + AsRawFd,
+    H: Write + AsFd,
 {
     /// Create a new `TimeoutWriter` with an optional timeout.
     ///
@@ -118,21 +119,21 @@ where
     pub fn new<T: Into<Option<Duration>>>(handle: H, timeout: T) -> TimeoutWriter<H> {
         TimeoutWriter {
             timeout: timeout.into().map(utils::duration_to_ms),
-            handle: handle,
+            handle,
         }
     }
 }
 
 pub trait TimeoutWriteExt<H>
 where
-    H: Write + AsRawFd,
+    H: Write + AsFd,
 {
     fn with_timeout<T: Into<Option<Duration>>>(self, timeout: T) -> TimeoutWriter<H>;
 }
 
 impl<H> TimeoutWriteExt<H> for H
 where
-    H: Write + AsRawFd,
+    H: Write + AsFd,
 {
     fn with_timeout<T: Into<Option<Duration>>>(self, timeout: T) -> TimeoutWriter<H> {
         TimeoutWriter::new(self, timeout)