veltrix 0.7.0

Unix helpers, service integrations, and Unicode metadata
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
135
136
137
138
139
140
141

/// systemd CLI backend configuration.
#[derive(Debug, Clone)]
pub struct SystemdCliSpec {
    /// systemctl executable name or path.
    pub systemctl: String,
    /// journalctl executable name or path.
    pub journalctl: String,
    /// Whether commands target the user service manager.
    pub user: bool,
    /// Whether to execute through sudo.
    pub sudo: bool,
}

/// systemd D-Bus backend configuration.
#[derive(Debug, Clone)]
pub struct SystemdDbusSpec {
    /// busctl executable name or path.
    pub busctl: String,
    /// Whether commands target the user service manager.
    pub user: bool,
    /// Whether to execute busctl through sudo.
    pub sudo: bool,
}

impl Default for SystemdDbusSpec {
    fn default() -> Self {
        Self {
            busctl: "busctl".to_string(),
            user: false,
            sudo: false,
        }
    }
}

impl SystemdDbusSpec {
    /// Create a default systemd D-Bus spec.
    pub fn new() -> Self {
        Self::default()
    }

    /// Target the user service manager.
    pub fn user(mut self) -> Self {
        self.user = true;
        self
    }

    /// Execute busctl through sudo.
    pub fn sudo(mut self) -> Self {
        self.sudo = true;
        self
    }

    /// Set the busctl executable.
    pub fn busctl(mut self, binary: impl Into<String>) -> Self {
        self.busctl = binary.into();
        self
    }
}

impl Default for SystemdCliSpec {
    fn default() -> Self {
        Self {
            systemctl: "systemctl".to_string(),
            journalctl: "journalctl".to_string(),
            user: false,
            sudo: false,
        }
    }
}

impl SystemdCliSpec {
    /// Create a default systemd CLI spec.
    pub fn new() -> Self {
        Self::default()
    }

    /// Target the user service manager.
    pub fn user(mut self) -> Self {
        self.user = true;
        self
    }

    /// Execute commands through sudo.
    pub fn sudo(mut self) -> Self {
        self.sudo = true;
        self
    }

    /// Set the systemctl executable.
    pub fn systemctl(mut self, binary: impl Into<String>) -> Self {
        self.systemctl = binary.into();
        self
    }

    /// Set the journalctl executable.
    pub fn journalctl(mut self, binary: impl Into<String>) -> Self {
        self.journalctl = binary.into();
        self
    }
}

/// Metadata describing the systemd backend used for a response.
#[derive(Debug, Clone)]
pub enum SystemdBackendUsed {
    /// systemctl/journalctl CLI backend.
    Cli { user: bool, sudo: bool },
    /// org.freedesktop.systemd1 D-Bus backend via busctl.
    Dbus {
        /// Whether the user manager bus was used.
        user: bool,
        /// Whether busctl was executed through sudo.
        sudo: bool,
        /// busctl executable name or path.
        busctl: String,
    },
}

/// Response wrapper for systemd operations with data.
#[derive(Debug, Clone)]
pub struct SystemdResponse<T> {
    pub backend: SystemdBackendUsed,
    pub data: T,
}

impl<T> SystemdResponse<T> {
    pub fn new(data: T, backend: SystemdBackendUsed) -> Self {
        Self { backend, data }
    }
}

/// Response wrapper for successful systemd operations with no body.
#[derive(Debug, Clone)]
pub struct SystemdEmptyResponse {
    pub backend: SystemdBackendUsed,
}

impl SystemdEmptyResponse {
    pub fn new(backend: SystemdBackendUsed) -> Self {
        Self { backend }
    }
}