refactor: Extract writer methods to FuseSessionExt trait

To reduce code duplication between the Linux and macOS FuseSession
implementations, this change extracts the with_writer and
try_with_writer helper methods into a new extension trait,
FuseSessionExt.

The trait provides default implementations for these methods, which rely
on file() and bufsize() accessor methods that the concrete session types
must provide. Both linux_session::FuseSession and
macos_session::FuseSession now implement this trait, allowing them to
share the common logic.

Author: Xu Jihui

src/transport/fusedev/linux_session.rs

@@ -24,6 +24,8 @@ use nix::poll::{poll, PollFd, PollFlags};
 use nix::sys::epoll::{epoll_ctl, EpollEvent, EpollFlags, EpollOp};
 use nix::unistd::{getgid, getuid, read};
 
+use crate::transport::fusedev::FuseSessionExt;
+
 use super::{
     super::pagesize,
     Error::{IoError, SessionFailure},
@@ -238,35 +240,6 @@ impl FuseSession {
         }
     }
 
-    /// Create a new fuse message writer and pass it to the given closure.
-    pub fn with_writer<F>(&mut self, f: F)
-    where
-        F: FnOnce(FuseDevWriter),
-    {
-        if let Some(file) = &self.file {
-            let fd = file.as_raw_fd();
-            let mut buf = vec![0x0u8; self.bufsize];
-            let writer = FuseDevWriter::new(fd, &mut buf).unwrap();
-            f(writer);
-        }
-    }
-
-    /// Create a new fuse message writer and pass it to the given closure. and return the result from the closure.
-    pub fn try_with_writer<F, R, E>(&mut self, f: F) -> std::result::Result<R, E>
-    where
-        F: FnOnce(FuseDevWriter) -> std::result::Result<R, E>,
-        E: From<super::Error>,
-    {
-        if let Some(file) = &self.file {
-            let fd = file.as_raw_fd();
-            let mut buf = vec![0x0u8; self.bufsize];
-            let writer = FuseDevWriter::new(fd, &mut buf)?;
-            f(writer)
-        } else {
-            Err(SessionFailure("invalid fuse session".into()).into())
-        }
-    }
-
     /// Wake channel loop and exit
     pub fn wake(&self) -> Result<()> {
         let wakers = self
@@ -297,6 +270,16 @@ impl Drop for FuseSession {
     }
 }
 
+impl FuseSessionExt for FuseSession {
+    fn file(&self) -> Option<&File> {
+        self.file.as_ref()
+    }
+
+    fn bufsize(&self) -> usize {
+        self.bufsize
+    }
+}
+
 /// A fuse channel abstraction.
 ///
 /// Each session can hold multiple channels.

src/transport/fusedev/macos_session.rs

@@ -203,6 +203,16 @@ impl Drop for FuseSession {
     }
 }
 
+impl FuseSessionExt for FuseSession {
+    fn file(&self) -> Option<&File> {
+        self.file.as_ref()
+    }
+
+    fn bufsize(&self) -> usize {
+        self.bufsize
+    }
+}
+
 /// A fuse channel abstruction. Each session can hold multiple channels.
 pub struct FuseChannel {
     file: File,

src/transport/fusedev/mod.rs

@@ -11,6 +11,7 @@ use std::collections::VecDeque;
 use std::io::{self, IoSlice, Write};
 use std::marker::PhantomData;
 use std::mem::ManuallyDrop;
+use std::os::fd::AsRawFd;
 use std::os::unix::io::RawFd;
 
 use nix::sys::uio::writev;
@@ -334,6 +335,45 @@ impl<S: BitmapSlice> Write for FuseDevWriter<'_, S> {
     }
 }
 
+/// Extension trait for FuseSession to provide helper methods.
+pub trait FuseSessionExt {
+
+    /// Get the underlying file of the fuse session.
+    fn file(&self) -> Option<&std::fs::File>;
+
+    /// Get the buffer size of the fuse session.
+    fn bufsize(&self) -> usize;
+
+    /// Create a new fuse message writer and pass it to the given closure.
+    fn with_writer<F>(&mut self, f: F)
+    where
+        F: FnOnce(FuseDevWriter),
+    {
+        if let Some(file) = self.file() {
+            let fd = file.as_raw_fd();
+            let mut buf = vec![0x0u8; self.bufsize()];
+            let writer = FuseDevWriter::new(fd, &mut buf).unwrap();
+            f(writer);
+        }
+    }
+
+    /// Create a new fuse message writer and pass it to the given closure. and return the result from the closure.
+    fn try_with_writer<F, R, E>(&mut self, f: F) -> std::result::Result<R, E>
+    where
+        F: FnOnce(FuseDevWriter) -> std::result::Result<R, E>,
+        E: From<Error>,
+    {
+        if let Some(file) = self.file() {
+            let fd = file.as_raw_fd();
+            let mut buf = vec![0x0u8; self.bufsize()];
+            let writer = FuseDevWriter::new(fd, &mut buf)?;
+            f(writer)
+        } else {
+            Err(Error::SessionFailure("invalid fuse session".into()).into())
+        }
+    }
+}
+
 #[cfg(feature = "async-io")]
 mod async_io {
     use super::*;

src/transport/mod.rs

@@ -42,7 +42,7 @@ mod virtiofs;
 
 pub use self::fs_cache_req_handler::FsCacheReqHandler;
 #[cfg(feature = "fusedev")]
-pub use self::fusedev::{FuseBuf, FuseChannel, FuseDevWriter, FuseSession};
+pub use self::fusedev::{FuseBuf, FuseChannel, FuseDevWriter, FuseSession, FuseSessionExt};
 #[cfg(feature = "virtiofs")]
 pub use self::virtiofs::VirtioFsWriter;
 

tests/passthrough/src/main.rs

@@ -1,3 +1,4 @@
+use fuse_backend_rs::transport::FuseSessionExt as _;
 use log::{error, info, warn, LevelFilter};
 use std::env;
 use std::fs;