girt 0.13.0

An incremental, idiomatic Rust implementation of Git
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

//! Explicit modes and regular-file synchronization shared by creation and index publication.
#[cfg(unix)]
use std::fs;
use std::fs::File;
use std::io;
use std::path::Path;

/// Permission adjustment for newly created shared repository metadata.
///
/// Adjustments use the created inode's mode; the process umask is never changed. Non-Unix hosts
/// currently support only [`Self::Umask`]. Callers must qualify other platform policies separately.
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
#[non_exhaustive]
pub enum SharedPermissions {
    /// Keep the operating system's creation mode and umask result.
    #[default]
    Umask,
    /// Add group read/write and directory traversal, retaining existing world permissions.
    Group,
    /// Also add world read and directory traversal; do not add world write.
    Everybody,
    /// Set exact permission bits, requiring owner read/write and a value at most `0o777`.
    ///
    /// File execute bits are discarded. Directories derive traversal from each read bit.
    /// APIs validate this value before publishing; an invalid value is never applied.
    Exact(u16),
}

impl SharedPermissions {
    pub(crate) fn validate(self) -> io::Result<()> {
        if let Self::Exact(mode) = self
            && (mode > 0o777 || mode & 0o600 != 0o600)
        {
            return Err(io::Error::new(
                io::ErrorKind::InvalidInput,
                "exact shared mode requires owner read/write and at most 0777",
            ));
        }
        #[cfg(not(unix))]
        if self != Self::Umask {
            return Err(io::Error::new(
                io::ErrorKind::Unsupported,
                "shared permission modes are not implemented on this platform",
            ));
        }
        Ok(())
    }

    pub(crate) fn apply_file(self, file: &File) -> io::Result<()> {
        self.validate()?;
        #[cfg(unix)]
        if self != Self::Umask {
            use std::os::unix::fs::PermissionsExt;
            let metadata = file.metadata()?;
            file.set_permissions(fs::Permissions::from_mode(
                self.mode(metadata.permissions().mode(), metadata.is_dir()),
            ))?;
        }
        #[cfg(not(unix))]
        let _ = file;
        Ok(())
    }

    pub(crate) fn apply_directory(self, path: &Path) -> io::Result<()> {
        self.validate()?;
        #[cfg(unix)]
        if self != Self::Umask {
            use std::os::unix::fs::PermissionsExt;
            let metadata = fs::metadata(path)?;
            fs::set_permissions(
                path,
                fs::Permissions::from_mode(self.mode(metadata.permissions().mode(), true)),
            )?;
        }
        #[cfg(not(unix))]
        let _ = path;
        Ok(())
    }

    #[cfg(unix)]
    fn mode(self, current: u32, directory: bool) -> u32 {
        match self {
            Self::Umask => current,
            Self::Group => current | if directory { 0o070 } else { 0o060 },
            Self::Everybody => current | if directory { 0o075 } else { 0o064 },
            Self::Exact(mode) => {
                let files = u32::from(mode) & 0o666;
                (current & !0o777) | files | if directory { (files & 0o444) >> 2 } else { 0 }
            }
        }
    }
}

/// Flush regular-file contents to the platform's strongest selected file-sync primitive.
/// Directory entries are not synchronized, and no power-loss guarantee is inferred from success.
pub(crate) fn sync_file(file: &File) -> io::Result<()> {
    #[cfg(target_os = "macos")]
    {
        rustix::fs::fcntl_fullfsync(file).map_err(Into::into)
    }
    #[cfg(not(target_os = "macos"))]
    {
        file.sync_all()
    }
}

#[cfg(all(test, unix))]
mod tests {
    use rstest::rstest;

    use super::*;

    #[rstest]
    #[case::umask_022(SharedPermissions::Umask, 0o644, 0o644, 0o755, 0o755)]
    #[case::group_022(SharedPermissions::Group, 0o644, 0o664, 0o755, 0o775)]
    #[case::group_077(SharedPermissions::Group, 0o600, 0o660, 0o700, 0o770)]
    #[case::group_world_write(SharedPermissions::Group, 0o666, 0o666, 0o777, 0o777)]
    #[case::everybody_077(SharedPermissions::Everybody, 0o600, 0o664, 0o700, 0o775)]
    #[case::everybody_world_write(SharedPermissions::Everybody, 0o666, 0o666, 0o777, 0o777)]
    #[case::exact_660(SharedPermissions::Exact(0o660), 0o644, 0o660, 0o755, 0o770)]
    #[case::exact_664(SharedPermissions::Exact(0o664), 0o600, 0o664, 0o700, 0o775)]
    #[case::exact_no_executable_file(SharedPermissions::Exact(0o777), 0o600, 0o666, 0o700, 0o777)]
    fn observed_mode_projection(
        #[case] policy: SharedPermissions,
        #[case] file: u32,
        #[case] expected_file: u32,
        #[case] directory: u32,
        #[case] expected_directory: u32,
    ) {
        policy.validate().unwrap();
        assert_eq!(policy.mode(file, false), expected_file);
        assert_eq!(policy.mode(directory, true), expected_directory);
    }
}