systemd_client 0.1.7

systemd client library implemented with dbus
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 std::io::Write;

use dbus::blocking::{self, stdintf::org_freedesktop_dbus::Introspectable};
use dbus_codegen::{self, ConnectionType, GenOpts};

const DESTINATION_SYSTEMD: &str = "org.freedesktop.systemd1";
const OBJECT_PATH_SYSTEMD_MANAGER: &str = "/org/freedesktop/systemd1";
const INTROSPECT_TIMEOUT_SECS: u64 = 10;

const OUTPUT_MANAGER_OBJECT_CLIENT: &str = "src/manager";

const MODULE_BLOCKING: &str = "blocking.rs";
const MODULE_NONBLOCK: &str = "nonblock.rs";

struct Generator<'a> {
    output: Option<&'a str>,
    object_path: Option<&'a str>,
    connection_type: Option<ConnectionType>,
}

impl<'a> Generator<'a> {
    pub fn new() -> Self {
        Generator {
            output: None,
            object_path: None,
            connection_type: None,
        }
    }

    pub fn output(mut self, output: &'a str) -> Self {
        self.output = Some(output);
        self
    }

    pub fn object_path(mut self, object_path: &'a str) -> Self {
        self.object_path = Some(object_path);
        self
    }

    pub fn connection_type(mut self, connection_type: ConnectionType) -> Self {
        self.connection_type = Some(connection_type);
        self
    }

    // fetch dbus xml definition of systemd
    fn introspect(object_path: &str) -> anyhow::Result<String> {
        let connection = blocking::Connection::new_system()?;
        let proxy = connection.with_proxy(
            DESTINATION_SYSTEMD,
            object_path,
            std::time::Duration::from_secs(INTROSPECT_TIMEOUT_SECS),
        );
        let definition = proxy.introspect()?;
        Ok(definition)
    }

    // write bytes to file
    fn write<P>(path: P, bytes: &[u8]) -> anyhow::Result<()>
    where
        P: AsRef<std::path::Path>,
    {
        let mut file = std::fs::File::create(path)?;
        file.write_all(bytes)?;
        file.flush()?;
        Ok(())
    }

    pub fn generate(self) -> anyhow::Result<()> {
        let output = self.output.expect("output directory undefined");
        let object_path = self.object_path.expect("object path undefined");
        let connection_type = self.connection_type.expect("connection type undefined");
        let output = match &connection_type {
            ConnectionType::Blocking => format!("{}/{}", output, MODULE_BLOCKING),
            ConnectionType::Nonblock => format!("{}/{}", output, MODULE_NONBLOCK),
            _ => unreachable!(),
        };
        let definition = Self::introspect(object_path)?;
        let opts = GenOpts {
            connectiontype: connection_type,
            methodtype: None,
            ..Default::default()
        };
        let code = dbus_codegen::generate(definition.as_str(), &opts).unwrap();
        Self::write(output, code.as_bytes())?;
        Ok(())
    }
}

fn main() {
    // generate manager object blocking proxy
    Generator::new()
        .object_path(OBJECT_PATH_SYSTEMD_MANAGER)
        .output(OUTPUT_MANAGER_OBJECT_CLIENT)
        .connection_type(ConnectionType::Blocking)
        .generate()
        .unwrap();
    // generate manager nonblock proxy
    Generator::new()
        .object_path(OBJECT_PATH_SYSTEMD_MANAGER)
        .output(OUTPUT_MANAGER_OBJECT_CLIENT)
        .connection_type(ConnectionType::Nonblock)
        .generate()
        .unwrap();
}