Start implementing LocalSource

src/local.rs

@@ -0,0 +1,186 @@
+use std::{
+    collections::BTreeMap,
+    fs, io,
+    os::unix::fs::{MetadataExt, PermissionsExt},
+    path::{Path, PathBuf},
+    time::{Duration, SystemTime},
+};
+
+use fuser::{Errno, FileAttr, Filesystem, INodeNo};
+
+#[derive(PartialEq, Eq, Copy, Clone, Debug)]
+enum FileType {
+    Directory,
+    File,
+}
+
+#[derive(Debug)]
+struct LocalItem {
+    inode: INodeNo,
+    name: String,
+    original_path: PathBuf,
+    local_path: PathBuf,
+    file_type: FileType,
+    metadata: fs::Metadata,
+}
+
+#[derive(Debug)]
+pub struct LocalOrigin {
+    source: PathBuf,
+    destination: PathBuf,
+    files: BTreeMap<INodeNo, LocalItem>,
+}
+
+impl LocalOrigin {
+    pub fn new(source: String, destination: String) -> Result<LocalOrigin, io::Error> {
+        println!("Initializing the LocalOrigin");
+
+        let mut map: BTreeMap<INodeNo, LocalItem> = BTreeMap::new();
+
+        let local_root = LocalItem {
+            inode: INodeNo::ROOT,
+            name: "/".to_string(),
+            original_path: PathBuf::from(&source),
+            local_path: PathBuf::from(&destination),
+            file_type: FileType::Directory,
+            metadata: fs::metadata(&source).unwrap(),
+        };
+        map.insert(INodeNo::ROOT, local_root);
+
+        match LocalOrigin::read_source(PathBuf::from(&source), Path::new(&destination), &mut map) {
+            Ok(_) => {
+                let local_origin = LocalOrigin {
+                    source: source.into(),
+                    destination: destination.into(),
+                    files: map,
+                };
+                dbg!(&local_origin);
+
+                return Ok(local_origin);
+            }
+            Err(err) => return Err(err),
+        }
+    }
+
+    fn read_source(
+        source: PathBuf,
+        destination: &Path,
+        map: &mut BTreeMap<INodeNo, LocalItem>,
+    ) -> Result<(), io::Error> {
+        match fs::read_dir(source) {
+            Ok(dir) => {
+                for item in dir {
+                    match item {
+                        Ok(entry) => {
+                            let name = entry.file_name().to_string_lossy().into_owned();
+                            let item_path: PathBuf = entry.path();
+                            let metadata: fs::Metadata = entry.metadata().unwrap();
+                            let file_type = if entry.file_type().unwrap().is_dir() {
+                                FileType::Directory
+                            } else {
+                                FileType::File
+                            };
+
+                            let mut local_path: PathBuf = PathBuf::new();
+                            local_path.push(destination);
+                            local_path.push(name.clone());
+
+                            let local_item = LocalItem {
+                                inode: INodeNo(metadata.ino()),
+                                name: name,
+                                original_path: item_path.clone(),
+                                local_path: local_path,
+                                file_type: file_type,
+                                metadata,
+                            };
+                            let inode = local_item.inode;
+
+                            map.insert(inode, local_item);
+
+                            if file_type == FileType::Directory {
+                                match LocalOrigin::read_source(item_path, destination, map) {
+                                    Ok(_) => {}
+                                    Err(err) => return Err(err),
+                                };
+                            }
+                        }
+
+                        Err(err) => return Err(err),
+                    }
+                }
+            }
+            Err(err) => return Err(err),
+        };
+
+        return Ok(());
+    }
+
+    fn local_file_to_file_attr(local_file: &LocalItem) -> FileAttr {
+        let metadata = &local_file.metadata;
+        let ctime = std::time::UNIX_EPOCH + Duration::from_secs(metadata.ctime() as u64);
+        let atime = metadata
+            .accessed()
+            .map_err(|err| {
+                println!("Failed to get atime for: {}", &local_file.name);
+                err
+            })
+            .unwrap();
+        let mtime = metadata
+            .modified()
+            .map_err(|err| {
+                println!("Failed to get atime for: {}", &local_file.name);
+                err
+            })
+            .unwrap();
+
+        let crtime = metadata
+            .created()
+            .map_err(|err| {
+                println!("Failed to get atime for: {}", &local_file.name);
+                err
+            })
+            .unwrap();
+        let kind = match local_file.file_type {
+            FileType::Directory => fuser::FileType::Directory,
+            FileType::File => fuser::FileType::RegularFile,
+        };
+
+        return FileAttr {
+            ino: local_file.inode,
+            size: metadata.size(),
+            blocks: metadata.blocks(),
+            atime: atime,
+            mtime: mtime,
+            ctime: ctime,
+            crtime: crtime,
+            kind: kind,
+            perm: metadata.permissions().mode() as u16,
+            nlink: metadata.nlink() as u32,
+            uid: metadata.uid(),
+            gid: metadata.gid(),
+            rdev: metadata.rdev() as u32,
+            blksize: metadata.blksize() as u32,
+            flags: 0, // TODO this is for macos only but perhaps we could get it from metadata still?
+        };
+    }
+}
+
+impl Filesystem for LocalOrigin {
+    fn getattr(
+        &self,
+        _req: &fuser::Request,
+        ino: INodeNo,
+        fh: Option<fuser::FileHandle>,
+        reply: fuser::ReplyAttr,
+    ) {
+        println!("getattr(ino={})", ino);
+        match self.files.get(&ino) {
+            Some(file) => {
+                let ttl = Duration::new(1, 0);
+                let attr = LocalOrigin::local_file_to_file_attr(file);
+                reply.attr(&ttl, &attr);
+            }
+            None => reply.error(Errno::ENOENT),
+        }
+    }
+}