fix: log

Author: veeso

CHANGELOG.md

@@ -1,9 +1,18 @@
 # Changelog
 
 - [Changelog](#changelog)
+  - [0.1.2](#012)
   - [0.1.1](#011)
   - [0.1.0](#010)
 
+---
+
+## 0.1.2
+
+Released on 23/10/2024
+
+- Added log
+
 ## 0.1.1
 
 Released on 22/10/2024

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "remotefs-memory"
-version = "0.1.1"
+version = "0.1.2"
 authors = ["Christian Visintin <[email protected]>"]
 edition = "2021"
 license = "MIT"

README.md

@@ -7,7 +7,7 @@
 <p align="center">~ A remotefs implementation for testing and simulation ~</p>
 
 <p align="center">Developed by <a href="https://veeso.github.io/" target="_blank">@veeso</a></p>
-<p align="center">Current version: 0.1.1</p>
+<p align="center">Current version: 0.1.2</p>
 
 <p align="center">
   <a href="https://opensource.org/licenses/MIT"

src/lib.rs

@@ -47,6 +47,9 @@
     html_logo_url = "https://raw.githubusercontent.com/remotefs-rs/remotefs-rs/main/assets/logo.png"
 )]
 
+#[macro_use]
+extern crate log;
+
 mod inode;
 #[cfg(test)]
 mod test;
@@ -164,23 +167,27 @@ impl MemoryFs {
 
 impl RemoteFs for MemoryFs {
     fn connect(&mut self) -> RemoteResult<Welcome> {
+        debug!("connect()");
         self.connected = true;
         Ok(Welcome::default())
     }
 
     fn disconnect(&mut self) -> RemoteResult<()> {
+        debug!("disconnect()");
         self.connected = false;
         Ok(())
     }
 
     fn is_connected(&mut self) -> bool {
+        debug!("is_connected() -> {}", self.connected);
         self.connected
     }
 
     fn pwd(&mut self) -> RemoteResult<PathBuf> {
         if !self.connected {
             return Err(RemoteError::new(RemoteErrorType::NotConnected));
         }
+        debug!("pwd() -> {:?}", self.wrkdir);
 
         Ok(self.wrkdir.clone())
     }
@@ -192,6 +199,8 @@ impl RemoteFs for MemoryFs {
 
         let dir = self.absolutize(dir);
 
+        debug!("change_dir({:?})", dir);
+
         // check if the directory exists
         let inode = self
             .tree
@@ -219,6 +228,7 @@ impl RemoteFs for MemoryFs {
         }
 
         let path = self.absolutize(path);
+        debug!("list_dir({:?})", path);
 
         // query node
         let node = self
@@ -232,6 +242,7 @@ impl RemoteFs for MemoryFs {
         for child in node.children() {
             let path = child.id().clone();
             let metadata = child.value().metadata().clone();
+            debug!("list_dir() -> {path:?}, {metadata:?}");
 
             files.push(File { path, metadata })
         }
@@ -245,6 +256,7 @@ impl RemoteFs for MemoryFs {
         }
 
         let path = self.absolutize(path);
+        debug!("stat({:?})", path);
 
         let node = self
             .tree
@@ -255,6 +267,8 @@ impl RemoteFs for MemoryFs {
         let path = node.id().clone();
         let metadata = node.value().metadata().clone();
 
+        debug!("stat({path:?}) -> {metadata:?}");
+
         Ok(File { path, metadata })
     }
 
@@ -264,6 +278,7 @@ impl RemoteFs for MemoryFs {
         }
 
         let path = self.absolutize(path);
+        debug!("setstat({:?}, {:?})", path, metadata);
 
         let node = self
             .tree
@@ -285,6 +300,7 @@ impl RemoteFs for MemoryFs {
         }
 
         let path = self.absolutize(path);
+        debug!("exists({:?})", path);
 
         Ok(self.tree.root().query(&path).is_some())
     }
@@ -295,6 +311,7 @@ impl RemoteFs for MemoryFs {
         }
 
         let path = self.absolutize(path);
+        debug!("remove_file({:?})", path);
 
         // get node
         let node = self
@@ -320,6 +337,7 @@ impl RemoteFs for MemoryFs {
         }
 
         let path = self.absolutize(path);
+        debug!("remove_dir({:?})", path);
 
         // get node
         let node = self
@@ -328,12 +346,18 @@ impl RemoteFs for MemoryFs {
             .query_mut(&path)
             .ok_or_else(|| RemoteError::new(RemoteErrorType::NoSuchFileOrDirectory))?;
         // check if is a leaf and is a directory
-        if !node.is_leaf() || node.value().metadata().file_type != FileType::Directory {
+        if !node.is_leaf() {
+            debug!("Directory {path:?} is not empty");
+            return Err(RemoteError::new(RemoteErrorType::DirectoryNotEmpty));
+        }
+        if node.value().metadata().file_type != FileType::Directory {
+            debug!("{path:?} is not a directory");
             return Err(RemoteError::new(RemoteErrorType::CouldNotRemoveFile));
         }
 
         let parent = self.tree.root_mut().parent_mut(&path).unwrap();
         parent.remove_child(&path);
+        debug!("removed {:?}", path);
 
         Ok(())
     }
@@ -344,6 +368,7 @@ impl RemoteFs for MemoryFs {
         }
 
         let path = self.absolutize(path);
+        debug!("remove_dir_all({:?})", path);
 
         let parent = self
             .tree
@@ -355,6 +380,7 @@ impl RemoteFs for MemoryFs {
             return Err(RemoteError::new(RemoteErrorType::NoSuchFileOrDirectory));
         }
         parent.remove_child(&path);
+        debug!("removed {:?}", path);
 
         Ok(())
     }
@@ -365,6 +391,7 @@ impl RemoteFs for MemoryFs {
         }
 
         let path = self.absolutize(path);
+        debug!("create_dir({:?})", path);
         let parent = path
             .parent()
             .unwrap_or_else(|| Path::new("/"))
@@ -380,11 +407,13 @@ impl RemoteFs for MemoryFs {
 
         // check if the directory already exists
         if parent.children().iter().any(|child| *child.id() == path) {
+            debug!("Directory {path:?} already exists");
             return Err(RemoteError::new(RemoteErrorType::DirectoryAlreadyExists));
         }
 
         // add the directory
         parent.add_child(Node::new(path.clone(), dir));
+        debug!("created directory {path:?}");
 
         Ok(())
     }
@@ -395,8 +424,10 @@ impl RemoteFs for MemoryFs {
         }
         let path = self.absolutize(path);
         let target = self.absolutize(target);
+        debug!("symlink({:?}, {:?})", path, target);
         // check if `target` exists
         if self.tree.root().query(&target).is_none() {
+            debug!("target {target:?} does not exist");
             return Err(RemoteError::new(RemoteErrorType::NoSuchFileOrDirectory));
         }
 
@@ -420,11 +451,13 @@ impl RemoteFs for MemoryFs {
 
         // check if the file already exists
         if parent.children().iter().any(|child| *child.id() == path) {
+            debug!("symbolic link {path:?} already exists");
             return Err(RemoteError::new(RemoteErrorType::FileCreateDenied));
         }
 
         // add the directory
         parent.add_child(Node::new(path.clone(), symlink));
+        debug!("symlink {path:?} -> {target:?}");
 
         Ok(())
     }
@@ -434,8 +467,9 @@ impl RemoteFs for MemoryFs {
             return Err(RemoteError::new(RemoteErrorType::NotConnected));
         }
         let src = self.absolutize(src);
-
         let dest = self.absolutize(dest);
+        debug!("copy({:?}, {:?})", src, dest);
+
         let dest_parent = dest
             .parent()
             .unwrap_or_else(|| Path::new("/"))
@@ -455,6 +489,7 @@ impl RemoteFs for MemoryFs {
             .query_mut(&dest_parent)
             .ok_or_else(|| RemoteError::new(RemoteErrorType::NoSuchFileOrDirectory))?;
 
+        debug!("copied {src:?} to {dest:?}");
         dest_parent.add_child(Node::new(dest, dest_inode));
 
         Ok(())
@@ -465,8 +500,9 @@ impl RemoteFs for MemoryFs {
             return Err(RemoteError::new(RemoteErrorType::NotConnected));
         }
         let src = self.absolutize(src);
-
         let dest = self.absolutize(dest);
+        debug!("mov({:?}, {:?})", src, dest);
+
         let dest_parent = dest
             .parent()
             .unwrap_or_else(|| Path::new("/"))
@@ -486,7 +522,7 @@ impl RemoteFs for MemoryFs {
             .query_mut(&dest_parent)
             .ok_or_else(|| RemoteError::new(RemoteErrorType::NoSuchFileOrDirectory))?;
 
-        dest_parent.add_child(Node::new(dest, dest_inode));
+        dest_parent.add_child(Node::new(dest.clone(), dest_inode));
 
         // remove src
         let src_parent = self
@@ -496,6 +532,7 @@ impl RemoteFs for MemoryFs {
             .ok_or_else(|| RemoteError::new(RemoteErrorType::NoSuchFileOrDirectory))?;
 
         src_parent.remove_child(&src);
+        debug!("moved {src:?} to {dest:?}");
 
         Ok(())
     }
@@ -509,6 +546,7 @@ impl RemoteFs for MemoryFs {
             return Err(RemoteError::new(RemoteErrorType::NotConnected));
         }
         let path = self.absolutize(path);
+        debug!("append({:?},{:?})", path, metadata);
         let parent = path
             .parent()
             .unwrap_or_else(|| Path::new("/"))
@@ -537,6 +575,7 @@ impl RemoteFs for MemoryFs {
         parent.add_child(Node::new(path.clone(), file));
 
         // make stream
+        debug!("file {path:?} opened for append");
         let handle = WriteHandle {
             path,
             data: Cursor::new(content.unwrap_or_default()),
@@ -553,6 +592,7 @@ impl RemoteFs for MemoryFs {
             return Err(RemoteError::new(RemoteErrorType::NotConnected));
         }
         let path = self.absolutize(path);
+        debug!("create({:?},{:?})", path, metadata);
         let parent = path
             .parent()
             .unwrap_or_else(|| Path::new("/"))
@@ -573,6 +613,7 @@ impl RemoteFs for MemoryFs {
 
         // add new file
         parent.add_child(Node::new(path.clone(), file));
+        debug!("{:?} created", path);
 
         // make stream
         let handle = WriteHandle {
@@ -591,13 +632,16 @@ impl RemoteFs for MemoryFs {
             return Err(RemoteError::new(RemoteErrorType::NotConnected));
         }
         let path = self.absolutize(path);
+        debug!("open({:?})", path);
 
         let node = self
             .tree
             .root()
             .query(&path)
             .ok_or_else(|| RemoteError::new(RemoteErrorType::NoSuchFileOrDirectory))?;
 
+        debug!("{:?} opened", path);
+
         let stream = Cursor::new(node.value().content.as_ref().cloned().unwrap_or_default());
         let stream = Box::new(stream) as Box<dyn Read + Send>;
 
@@ -606,6 +650,7 @@ impl RemoteFs for MemoryFs {
 
     fn on_written(&mut self, writable: WriteStream) -> RemoteResult<()> {
         let handle = Self::downcast_write_handle(writable);
+        debug!("on_written({:?}, {:?})", handle.path, handle.mode);
 
         // get node
         let node = self
@@ -632,6 +677,7 @@ impl RemoteFs for MemoryFs {
             }
             WriteMode::Create => handle.data.get_ref().len() as u64,
         };
+        debug!("{:?} written {:?}", handle.path, value);
         node.set_value(value);
 
         Ok(())