Remove blocking calls from Driver trait

Blocking and queuing semantics should be handled at a higher level.
Open-Agriculture · Aug 8, 2023 · 63cd366 · 63cd366
1 parent 4ce5cc9
commit 63cd366
Show file tree

Hide file tree

Showing 3 changed files with 2 additions and 57 deletions.
diff --git a/examples/forward.rs b/examples/forward.rs
@@ -22,10 +22,6 @@ struct Options {
     /// Can be either a string interface name, or an integer interface index
     #[clap(short, long, default_value_t = String::from("can1"))]
     pub output_interface: String,
-
-    /// Whether to use blocking send()/recv()s
-    #[clap(short, long)]
-    pub blocking: bool,
 }
 
 fn create_driver(iface: &str) -> impl Driver {
@@ -36,22 +32,6 @@ fn create_driver(iface: &str) -> impl Driver {
     }
 }
 
-fn read(input: &mut impl Driver, frame: &mut Frame, blocking: bool) -> Result<(), DriverReadError> {
-    if blocking {
-        input.read_blocking(frame)
-    } else {
-        input.read_nonblocking(frame)
-    }
-}
-
-fn write(output: &mut impl Driver, frame: &Frame, blocking: bool) -> Result<(), DriverWriteError> {
-    if blocking {
-        output.write_blocking(frame)
-    } else {
-        output.write_nonblocking(frame)
-    }
-}
-
 fn main() {
     let opts = Options::parse();
 
@@ -84,11 +64,11 @@ fn main() {
 
         let mut frame = Frame::default();
 
-        match read(&mut input, &mut frame, opts.blocking) {
+        match input.read(&mut frame) {
             Ok(_) => {
                 tracing::info!("Read frame: {frame:?}");
                 tracing::info!("Attempting to write frame");
-                match write(&mut output, &frame, opts.blocking) {
+                match output.write(&frame) {
                     Ok(_) => tracing::info!("Wrote frame: {frame:?}"),
                     Err(e) => tracing::info!("Failed to write frame: {e:?}"),
                 }

diff --git a/src/driver/driver.rs b/src/driver/driver.rs
@@ -101,11 +101,6 @@ pub trait Driver {
     fn open(&mut self) -> Result<(), DriverOpenError>;
     fn close(&mut self) -> Result<(), DriverCloseError>;
 
-    fn read_blocking(&mut self, frame: &mut Frame) -> Result<(), DriverReadError>;
     fn read_nonblocking(&mut self, frame: &mut Frame) -> Result<(), DriverReadError>;
-
-    // TODO: Do we force every driver to implement this method? Or maybe we provide a default
-    // implementation that they can override?
-    fn write_blocking(&mut self, frame: &Frame) -> Result<(), DriverWriteError>;
     fn write_nonblocking(&mut self, frame: &Frame) -> Result<(), DriverWriteError>;
 }
diff --git a/src/driver/socketcan.rs b/src/driver/socketcan.rs
@@ -69,26 +69,6 @@ impl Driver for SocketcanDriver {
         Ok(())
     }
 
-    fn read_blocking(&mut self, _frame: &mut Frame) -> Result<(), DriverReadError> {
-        let Some(sock) = self.sock.as_mut() else {
-            return Err(DriverReadError::DriverClosed);
-        };
-
-        loop {
-            // Use a timeout so that we're not calling the non-blocking read_frame() over and over
-            // as fast as possible.
-            match sock.read_frame_timeout(std::time::Duration::from_millis(100)) {
-                Ok(_frame) => {
-                    // TODO: convert socketcan CanFrame to Frame
-                    return Ok(());
-                }
-                Err(e) => match e.kind() {
-                    std::io::ErrorKind::TimedOut => {}
-                    _ => return Err(e.into()),
-                },
-            }
-        }
-    }
     fn read_nonblocking(&mut self, _frame: &mut Frame) -> Result<(), DriverReadError> {
         let Some(sock) = self.sock.as_mut() else {
             return Err(DriverReadError::DriverClosed);
@@ -97,16 +77,6 @@ impl Driver for SocketcanDriver {
         // TODO: Convert socketcan CanFrame to Frame.
         Ok(())
     }
-
-    fn write_blocking(&mut self, _frame: &Frame) -> Result<(), DriverWriteError> {
-        let Some(sock) = self.sock.as_mut() else {
-            return Err(DriverWriteError::DriverClosed);
-        };
-        // TODO: Convert Frame to socketcan CanFrame
-        let socketcan_frame = socketcan::CanFrame::default();
-        sock.write_frame_insist(&socketcan_frame)?;
-        Ok(())
-    }
     fn write_nonblocking(&mut self, _frame: &Frame) -> Result<(), DriverWriteError> {
         let Some(sock) = self.sock.as_mut() else {
             return Err(DriverWriteError::DriverClosed);