From 9ae9ea065c0824240203d4f17b2a644364d89276 Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Fri, 20 Dec 2024 06:39:24 +0800 Subject: [PATCH] feat: implement FuseApiHandleDebug --- .../filesystem-fuse/src/fuse_api_handle.rs | 165 +++++++++++++++++- 1 file changed, 164 insertions(+), 1 deletion(-) diff --git a/clients/filesystem-fuse/src/fuse_api_handle.rs b/clients/filesystem-fuse/src/fuse_api_handle.rs index 2a1a83531d2..b9d91e816a1 100644 --- a/clients/filesystem-fuse/src/fuse_api_handle.rs +++ b/clients/filesystem-fuse/src/fuse_api_handle.rs @@ -35,6 +35,169 @@ use std::ffi::{OsStr, OsString}; use std::num::NonZeroU32; use std::time::{Duration, SystemTime}; +pub(crate) struct FuseApiHandleDebug { + inner: FuseApiHandle, +} + +impl FuseApiHandleDebug { + pub fn new(fs: T, context: FileSystemContext) -> Self { + Self { + inner: FuseApiHandle::new(fs, context), + } + } + + pub async fn get_file_path(&self, file_id: u64) -> String { + debug!("get_file_path: file_id: {}", file_id); + let result = self.inner.get_file_path(file_id).await; + debug!("get_file_path result: {}", result); + result + } + + async fn get_modified_file_stat( + &self, + file_id: u64, + size: Option, + atime: Option, + mtime: Option, + ) -> Result { + debug!("get_modified_file_stat: file_id: {}, size: {:?}, atime: {:?}, mtime: {:?}", file_id, size, atime, mtime); + let result = self.inner.get_modified_file_stat(file_id, size, atime, mtime).await; + debug!("get_modified_file_stat result: {:?}", result); + result + } +} + +impl Filesystem for FuseApiHandleDebug { + async fn init(&self, req: Request) -> fuse3::Result { + debug!("init: req: {:?}", req); + let result = self.inner.init(req).await; + debug!("init result: {:?}", result); + result + } + + async fn destroy(&self, req: Request) { + debug!("destroy: req: {:?}", req); + self.inner.destroy(req).await; + debug!("destroy completed"); + } + + async fn lookup(&self, req: Request, parent: Inode, name: &OsStr) -> fuse3::Result { + debug!("lookup: req: {:?}, parent: {:?}, name: {:?}", req, parent, name); + let result = self.inner.lookup(req, parent, name).await; + debug!("lookup result: {:?}", result); + result + } + + async fn getattr(&self, req: Request, inode: Inode, fh: Option, flags: u32) -> fuse3::Result { + debug!("getattr: req: {:?}, inode: {:?}, fh: {:?}, flags: {:?}", req, inode, fh, flags); + let result = self.inner.getattr(req, inode, fh, flags).await; + debug!("getattr result: {:?}", result); + result + } + + async fn setattr(&self, req: Request, inode: Inode, fh: Option, set_attr: SetAttr) -> fuse3::Result { + debug!("setattr: req: {:?}, inode: {:?}, fh: {:?}, set_attr: {:?}", req, inode, fh, set_attr); + let result = self.inner.setattr(req, inode, fh, set_attr).await; + debug!("setattr result: {:?}", result); + result + } + + async fn mkdir(&self, req: Request, parent: Inode, name: &OsStr, mode: u32, umask: u32) -> fuse3::Result { + debug!("mkdir: req: {:?}, parent: {:?}, name: {:?}, mode: {}, umask: {}", req, parent, name, mode, umask); + let result = self.inner.mkdir(req, parent, name, mode, umask).await; + debug!("mkdir result: {:?}", result); + result + } + + async fn unlink(&self, req: Request, parent: Inode, name: &OsStr) -> fuse3::Result<()> { + debug!("unlink: req: {:?}, parent: {:?}, name: {:?}", req, parent, name); + let result = self.inner.unlink(req, parent, name).await; + debug!("unlink result: {:?}", result); + result + } + + async fn rmdir(&self, req: Request, parent: Inode, name: &OsStr) -> fuse3::Result<()> { + debug!("rmdir: req: {:?}, parent: {:?}, name: {:?}", req, parent, name); + let result = self.inner.rmdir(req, parent, name).await; + debug!("rmdir result: {:?}", result); + result + } + + async fn open(&self, req: Request, inode: Inode, flags: u32) -> fuse3::Result { + debug!("open: req: {:?}, inode: {:?}, flags: {:?}", req, inode, flags); + let result = self.inner.open(req, inode, flags).await; + debug!("open result: {:?}", result); + result + } + + async fn read(&self, req: Request, inode: Inode, fh: u64, offset: u64, size: u32) -> fuse3::Result { + debug!("read: req: {:?}, inode: {:?}, fh: {:?}, offset: {:?}, size: {:?}", req, inode, fh, offset, size); + let result = self.inner.read(req, inode, fh, offset, size).await; + debug!("read result: {:?}", result); + result + } + + async fn write(&self, req: Request, inode: Inode, fh: u64, offset: u64, data: &[u8], write_flags: u32, flags: u32) -> fuse3::Result { + debug!("write: req: {:?}, inode: {:?}, fh: {:?}, offset: {:?}, data_len: {}, write_flags: {:?}, flags: {:?}", req, inode, fh, offset, data.len(), write_flags, flags); + let result = self.inner.write(req, inode, fh, offset, data, write_flags, flags).await; + debug!("write result: {:?}", result); + result + } + + async fn statfs(&self, req: Request, inode: Inode) -> fuse3::Result { + debug!("statfs: req: {:?}, inode: {:?}", req, inode); + let result = self.inner.statfs(req, inode).await; + debug!("statfs result: {:?}", result); + result + } + + async fn release(&self, req: Request, inode: Inode, fh: u64, flags: u32, lock_owner: u64, flush: bool) -> fuse3::Result<()> { + debug!("release: req: {:?}, inode: {:?}, fh: {:?}, flags: {:?}, lock_owner: {:?}, flush: {:?}", req, inode, fh, flags, lock_owner, flush); + let result = self.inner.release(req, inode, fh, flags, lock_owner, flush).await; + debug!("release result: {:?}", result); + result + } + + async fn opendir(&self, req: Request, inode: Inode, flags: u32) -> fuse3::Result { + debug!("opendir: req: {:?}, inode: {:?}, flags: {:?}", req, inode, flags); + let result = self.inner.opendir(req, inode, flags).await; + debug!("opendir result: {:?}", result); + result + } + + type DirEntryStream<'a> = BoxStream<'a, fuse3::Result> where T: 'a; + + async fn readdir<'a>(&'a self, req: Request, parent: Inode, fh: u64, offset: i64) -> fuse3::Result>> { + debug!("readdir: req: {:?}, parent: {:?}, fh: {:?}, offset: {:?}", req, parent, fh, offset); + let result = self.inner.readdir(req, parent, fh, offset).await; + debug!("readdir result: {:?}", result); + result + } + + async fn releasedir(&self, req: Request, inode: Inode, fh: u64, flags: u32) -> fuse3::Result<()> { + debug!("releasedir: req: {:?}, inode: {:?}, fh: {:?}, flags: {:?}", req, inode, fh, flags); + let result = self.inner.releasedir(req, inode, fh, flags).await; + debug!("releasedir result: {:?}", result); + result + } + + async fn create(&self, req: Request, parent: Inode, name: &OsStr, mode: u32, flags: u32) -> fuse3::Result { + debug!("create: req: {:?}, parent: {:?}, name: {:?}, mode: {:?}, flags: {:?}", req, parent, name, mode, flags); + let result = self.inner.create(req, parent, name, mode, flags).await; + debug!("create result: {:?}", result); + result + } + + type DirEntryPlusStream<'a> = BoxStream<'a, fuse3::Result> where T: 'a; + + async fn readdirplus<'a>(&'a self, req: Request, parent: Inode, fh: u64, offset: u64, lock_owner: u64) -> fuse3::Result>> { + debug!("readdirplus: req: {:?}, parent: {:?}, fh: {:?}, offset: {:?}, lock_owner: {:?}", req, parent, fh, offset, lock_owner); + let result = self.inner.readdirplus(req, parent, fh, offset, lock_owner).await; + debug!("readdirplus result: {:?}", result); + result + } +} + pub(crate) struct FuseApiHandle { fs: T, default_ttl: Duration, @@ -453,7 +616,7 @@ impl Filesystem for FuseApiHandle { } fn fstat_to_file_attr(file_st: &FileStat, context: &FileSystemContext) -> FileAttr { - debug!("fs_st: {:?}, context: {:?}", file_st, context); + debug!("file_st: {:?}, context: {:?}", file_st, context); debug_assert!(file_st.file_id != 0 && file_st.parent_file_id != 0); FileAttr { ino: file_st.file_id,