libsystemd 0.7.2

A pure-Rust client library to interact with systemd
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

use super::*;
use std::fmt::{self, Display};

impl Display for SysusersEntry {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            SysusersEntry::AddRange(v) => write!(f, "{}", v),
            SysusersEntry::AddUserToGroup(v) => write!(f, "{}", v),
            SysusersEntry::CreateGroup(v) => write!(f, "{}", v),
            SysusersEntry::CreateUserAndGroup(v) => write!(f, "{}", v),
        }
    }
}

impl Display for AddRange {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "r - {}-{} - - -", self.from, self.to)
    }
}

impl Display for AddUserToGroup {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "m {} {} - - -", self.username, self.groupname,)
    }
}

impl Display for CreateGroup {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "g {} {} - - -", self.groupname, self.gid,)
    }
}

impl Display for CreateUserAndGroup {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "u {} {} \"{}\" {} {}",
            self.name,
            self.id,
            self.gecos,
            self.home_dir
                .as_deref()
                .map(|p| p.to_string_lossy())
                .unwrap_or(Cow::Borrowed("-")),
            self.shell
                .as_deref()
                .map(|p| p.to_string_lossy())
                .unwrap_or(Cow::Borrowed("-")),
        )
    }
}

impl Display for IdOrPath {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            IdOrPath::Id(i) => write!(f, "{}", i),
            IdOrPath::UidGid((u, g)) => write!(f, "{}:{}", u, g),
            IdOrPath::UidGroupname((u, g)) => write!(f, "{}:{}", u, g),
            IdOrPath::Path(p) => write!(f, "{}", p.display()),
            IdOrPath::Automatic => write!(f, "-",),
        }
    }
}

impl Display for GidOrPath {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            GidOrPath::Gid(g) => write!(f, "{}", g),
            GidOrPath::Path(p) => write!(f, "{}", p.display()),
            GidOrPath::Automatic => write!(f, "-",),
        }
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn test_formatters() {
        {
            let type_u =
                CreateUserAndGroup::new("foo0".to_string(), "test".to_string(), None, None)
                    .unwrap();
            let expected = r#"u foo0 - "test" - -"#;
            assert_eq!(type_u.to_string(), expected);
        }
        {
            let type_g = CreateGroup::new("foo1".to_string()).unwrap();
            let expected = r#"g foo1 - - - -"#;
            assert_eq!(type_g.to_string(), expected);
        }
        {
            let type_r = AddRange::new(10, 20).unwrap();
            let expected = r#"r - 10-20 - - -"#;
            assert_eq!(type_r.to_string(), expected);
        }
        {
            let type_m = AddUserToGroup::new("foo3".to_string(), "bar".to_string()).unwrap();
            let expected = r#"m foo3 bar - - -"#;
            assert_eq!(type_m.to_string(), expected);
        }
    }
}