hyperfile 0.9.0

A file-like interface abstraction layer provides random read and write capabilities for S3
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use std::fmt;

#[derive(Clone)]
pub struct HyperFileMode {
    pub mode: FileMode,
}

impl HyperFileMode {
    pub fn from_mode(mode: FileMode) -> Self {
        Self {
            mode,
        }
    }

    pub fn to_u32(&self) -> u32 {
        self.mode.0 as u32
    }
}

#[derive(Clone)]
pub struct FileMode(libc::mode_t);

impl fmt::Display for FileMode {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        if self.is_reg() {
            write!(f, "S_IFREG")?;
        }
        if self.is_dir() {
            write!(f, "S_IFDIR")?;
        }
        let perm = self.0 & !libc::S_IFMT;
        write!(f, " | {:#o}", perm)
    }
}

impl FileMode {
    pub fn from(mode: libc::mode_t) -> Self {
        Self(mode)
    }

    pub fn default_dir() -> Self {
        // o755
        Self(
            libc::S_IFDIR | libc::S_IRWXU | libc::S_IWUSR | libc::S_IRGRP | libc::S_IXGRP | libc::S_IROTH | libc::S_IXOTH
        )
    }

    pub fn default_file() -> Self {
        // o644
        Self(
            libc::S_IFREG | libc::S_IRUSR | libc::S_IWUSR | libc::S_IRGRP | libc::S_IROTH
        )
    }

    pub fn is_reg(&self) -> bool {
        (self.0 & libc::S_IFREG) == libc::S_IFREG
    }

    pub fn is_dir(&self) -> bool {
        (self.0 & libc::S_IFDIR) == libc::S_IFDIR
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    // `to_u32` is the same 32-bit mode domain the on-disk inode uses.
    use crate::ondisk::mode_bits;

    #[test]
    fn file_mode_default_file() {
        let m = FileMode::default_file();
        assert!(m.is_reg());
        assert!(!m.is_dir());
    }

    #[test]
    fn file_mode_default_dir() {
        let m = FileMode::default_dir();
        assert!(m.is_dir());
        assert!(!m.is_reg());
    }

    #[test]
    fn file_mode_from_raw() {
        let m = FileMode::from(libc::S_IFREG | 0o755);
        assert!(m.is_reg());
        assert!(!m.is_dir());
    }

    #[test]
    fn hyper_file_mode_to_u32_round_trip() {
        let fm = FileMode::from(libc::S_IFREG | 0o644);
        let hm = HyperFileMode::from_mode(fm);
        let val = hm.to_u32();
        assert_eq!(val & mode_bits::S_IFMT, mode_bits::S_IFREG);
        assert_eq!(val & !mode_bits::S_IFMT, 0o644);
    }

    #[test]
    fn hyper_file_mode_permissions_only() {
        let fm = FileMode::from(0o755); // no file type bits
        let hm = HyperFileMode::from_mode(fm);
        assert_eq!(hm.to_u32() & mode_bits::S_IFMT, 0);
        assert_eq!(hm.to_u32() & !mode_bits::S_IFMT, 0o755);
    }

    #[test]
    fn file_mode_display() {
        let m = FileMode::default_file();
        let s = format!("{}", m);
        assert!(s.contains("S_IFREG"));
    }
}