desk-logind 1.1.1

Bindings for the systemd-logind D-Bus API
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

//! `systemd-logind` client library
#![feature(backtrace)]
use std::env;
use std::time::Duration;

use dbus::blocking::{Connection, Proxy};
use dbus::Message;

use crate::api::manager::{
    OrgFreedesktopLogin1Manager, OrgFreedesktopLogin1ManagerPrepareForSleep,
};
pub use crate::error::LogindError;
use crate::inhibitor::{InhibitEventSet, InhibitMode, InhibitorLock};
pub use crate::session::{Session, SessionId};

mod api;
mod error;
pub mod inhibitor;
mod session;

pub fn session_id() -> Result<SessionId, LogindError> {
    match env::var("XDG_SESSION_ID") {
        Ok(id) => Ok(SessionId::new(id)),
        Err(_) => Err(LogindError::no_session_id()),
    }
}

/// A logind client connection. This is a relatively thin wrapper over the
/// [D-Bus API](https://www.freedesktop.org/wiki/Software/systemd/logind/).
pub struct Logind<'a> {
    conn: &'a Connection,
    timeout: Duration,
}

impl<'a> Logind<'a> {
    pub fn new(conn: &'a Connection) -> Logind {
        Logind {
            conn,
            timeout: Duration::from_millis(500),
        }
    }

    /// Get a handle to a logind session by ID.
    pub fn session(&self, id: &SessionId) -> Result<Session<'a>, LogindError> {
        let manager = self.manager();
        let path = manager.get_session(id.as_str())?;
        let proxy = Proxy::new(
            "org.freedesktop.login1",
            path,
            self.timeout,
            self.conn,
        );
        Ok(Session::new(proxy))
    }

    /// Get a handle to the current logind session.
    pub fn current_session(&self) -> Result<Session<'a>, LogindError> {
        let id = session_id()?;
        self.session(&id)
    }

    /// Attempt to suspend the system. If `interactive`, PolicyKit may prompt the current user
    /// for authentication if needed.
    pub fn suspend(&self, interactive: bool) -> Result<(), LogindError> {
        let manager = self.manager();
        manager.suspend(interactive)?;
        Ok(())
    }

    /// Attempt to reboot the system. If `interactive`, PolicyKit may prompt the current user for
    /// authentication.
    pub fn reboot(&self, interactive: bool) -> Result<(), LogindError> {
        let manager = self.manager();
        manager.reboot(interactive)?;
        Ok(())
    }

    /// Attempt to power off the system. If `interactive`, PolicyKit may prompt the current user for
    /// authentication.
    pub fn power_off(&self, interactive: bool) -> Result<(), LogindError> {
        let manager = self.manager();
        manager.power_off(interactive)?;
        Ok(())
    }

    /// Attempt to hibernate the system. If `interactive`, PolicyKit may prompt the current user for
    /// authentication.
    pub fn hibernate(&self, interactive: bool) -> Result<(), LogindError> {
        let manager = self.manager();
        manager.hibernate(interactive)?;
        Ok(())
    }

    pub fn inhibit(
        &self,
        who: &str,
        why: &str,
        events: &InhibitEventSet,
        mode: InhibitMode,
    ) -> Result<InhibitorLock, LogindError> {
        let manager = self.manager();
        let fd = manager.inhibit(events.as_str(), who, why, mode.as_str())?;
        Ok(InhibitorLock::new(fd))
    }

    pub fn on_sleep<F: Fn(Logind) + Send + 'static, G: Fn(Logind) + Send + 'static>(
        &self,
        pre_sleep: F,
        post_sleep: G,
    ) -> Result<(), LogindError> {
        let manager = self.manager();
        match manager.match_signal(
            move |signal: OrgFreedesktopLogin1ManagerPrepareForSleep,
                  conn: &Connection,
                  _: &Message| {
                if signal.arg0 {
                    // TODO: would be nice to make `Logind` less tied to dbus' threading model where we have to keep making new instances
                    pre_sleep(Logind::new(conn));
                } else {
                    post_sleep(Logind::new(conn));
                }
                true
            },
        ) {
            Ok(_) => Ok(()),
            Err(e) => Err(LogindError::match_failed("PrepareForSleep", e)),
        }
    }

    fn manager(&self) -> Proxy<'_, &'a Connection> {
        Proxy::new(
            "org.freedesktop.login1",
            "/org/freedesktop/login1",
            self.timeout,
            self.conn,
        )
    }
}