sysd-manager-proxy 2.13.0

Simple lib used by sysd-manager to perform privileged operations via polkit over D-Bus.
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

use base::{consts::DBUS_DESTINATION_DEV, enums::UnitDBusLevel, proxy::DisEnAbleUnitFiles};
use tracing::info;

use test_base::init_logs;
use zbus::proxy;

/* pub const DBUS_NAME: &str = "io.github.plrigaux.SysDManager";
pub const DBUS_NAME_DEV: &str = concat!(DBUS_NAME, "Dev");
pub const DBUS_INTERFACE: &str = DBUS_NAME;
pub const DBUS_DESTINATION: &str = DBUS_NAME;
pub const DBUS_DESTINATION_DEV: &str = DBUS_NAME_DEV;
pub const DBUS_PATH: &str = "/io/github/plrigaux/SysDManager";
pub const DBUS_PATH_DEV: &str = concat!(DBUS_PATH, "Dev"); */

#[proxy(
    interface = "io.github.plrigaux.SysDManager",
    default_service = "io.github.plrigaux.SysDManagerDev",
    default_path = "/io/github/plrigaux/SysDManager"
)]
pub trait SysDProxyTester {
    fn clean_unit(&self, unit_name: &str, what: &[&str]) -> zbus::Result<()>;

    fn my_user_id(&self) -> zbus::Result<u32>;

    fn even_ping(&self, val: u32) -> zbus::Result<u32>;

    fn revert_unit_files(
        &self,
        bus: u8,
        unit_names: &[&str],
    ) -> zbus::Result<Vec<DisEnAbleUnitFiles>>;
}

async fn system() -> zbus::Result<zbus::Connection> {
    zbus::Connection::system().await
}

async fn system_proxy<'a>() -> zbus::Result<SysDProxyTesterProxy<'a>> {
    let conn = system().await?;
    let proxy = SysDProxyTesterProxy::builder(&conn)
        .destination(DBUS_DESTINATION_DEV)?
        .build()
        .await?;

    Ok(proxy)
}

/* async fn session() -> zbus::Result<zbus::Connection> {
    zbus::Connection::session().await
} */

#[ignore = "need a connection to a service"]
#[tokio::test]
async fn test_sysd_proxy_tester() -> zbus::Result<()> {
    init_logs();
    let conn = system().await?;
    let _proxy = SysDProxyTesterProxy::builder(&conn).build().await?;
    Ok(())
}

#[ignore = "need a connection to a service"]
#[tokio::test]
async fn test_get_user_id() -> zbus::Result<()> {
    init_logs();
    let proxy = system_proxy().await?;

    let uid = proxy.my_user_id().await?;

    info!("User id from proxy: {}", uid);
    Ok(())
}

#[ignore = "need a connection to a service"]
#[tokio::test]
async fn test_even_ping() -> zbus::Result<()> {
    init_logs();
    let proxy = system_proxy().await?;

    let val = proxy.even_ping(42).await?;

    info!("Value returned {}", val);
    Ok(())
}

#[ignore = "need a connection to a service"]
#[tokio::test]
async fn test_even_ping_fail() -> zbus::Result<()> {
    init_logs();
    let proxy = system_proxy().await?;

    match proxy.even_ping(43).await {
        Ok(val) => {
            panic!("Should not succeed, got {}", val);
        }
        Err(zbus::Error::MethodError(a, _b, _c)) => {
            let inner: &zbus::names::ErrorName<'_> = a.inner();
            info!("Expected error received: {}", inner);
        }
        Err(e) => {
            info!("Expected error received: {}", e);
        }
    }

    Ok(())
}

#[ignore = "need a connection to a service"]
#[tokio::test]
async fn test_revert_unit_files() -> zbus::Result<()> {
    init_logs();
    let proxy = system_proxy().await?;

    match proxy
        .revert_unit_files(
            UnitDBusLevel::UserSession.index(),
            &["tiny_plr_daemon.service"],
        )
        .await
    {
        Ok(val) => {
            panic!("Should not succeed, got {:?}", val);
        }

        Err(e) => {
            info!("Expected error received: {}", e);
        }
    }

    Ok(())
}