Struct LibseatBackend 

pub struct LibseatBackend { /* private fields */ }

Available on crate feature libseat only.

A session backed by libseat.

Whichever backend libseat finds: logind, seatd, or the builtin fallback for a process running as root on a TTY. LIBSEAT_BACKEND picks one explicitly.

Implementations

impl LibseatBackend

pub fn open() -> Result<Self, SessionError>

Connect to whatever seat is available, and wait for it to activate.

Errors

• SessionError::NoBackend when there is no seat. That is the ordinary case outside a login session – over SSH, in a container, on a CI runner – and a caller that only wants to look at a display can open devices directly instead. What it gives up is surviving a VT switch. The same when the backend connects but does not activate the seat within DEFAULT_ENABLE_TIMEOUT – seatd over SSH, with no VT to take – so the caller falls back the same way. And the same when a dispatch fails before the seat activates, as the reference falls back on it.

Examples found in repository

examples/seat.rs (line 20)

fn main() {
    let paths: Vec<String> = std::env::args().skip(1).collect();

    let mut backend = match drmkit_session::LibseatBackend::open() {
        Ok(backend) => backend,
        Err(SessionError::NoBackend) => {
            println!("no seat here: not a login session, no seatd, no root TTY");
            return;
        }
        Err(error) => {
            eprintln!("seat: {error}");
            std::process::exit(1);
        }
    };

    println!("seat: {}", backend.name());
    let mut session = Session::new(backend);

    for path in &paths {
        match session.take_device(path) {
            Ok(device) => println!("  {path}: fd {}", device.fd),
            Err(error) => println!("  {path}: {error}"),
        }
    }

    if paths.is_empty() {
        println!("pass device paths to open some");
    }
}

pub fn open_within(timeout: Option<Duration>) -> Result<Self, SessionError>

As open, waiting up to timeout for the seat to activate; None waits indefinitely.

Without a bound, a backend that connects but never activates the seat blocked forever, and SIGINT could not break the wait, so the process kept DRM master (drm-cxx 60c6f10). On timeout the seat is closed.

Errors

As open.

pub fn name(&mut self) -> &str

The seat’s name, for logging.

Examples found in repository

examples/seat.rs (line 32)

fn main() {
    let paths: Vec<String> = std::env::args().skip(1).collect();

    let mut backend = match drmkit_session::LibseatBackend::open() {
        Ok(backend) => backend,
        Err(SessionError::NoBackend) => {
            println!("no seat here: not a login session, no seatd, no root TTY");
            return;
        }
        Err(error) => {
            eprintln!("seat: {error}");
            std::process::exit(1);
        }
    };

    println!("seat: {}", backend.name());
    let mut session = Session::new(backend);

    for path in &paths {
        match session.take_device(path) {
            Ok(device) => println!("  {path}: fd {}", device.fd),
            Err(error) => println!("  {path}: {error}"),
        }
    }

    if paths.is_empty() {
        println!("pass device paths to open some");
    }
}

Trait Implementations

impl Backend for LibseatBackend

fn open_device( &mut self, path: &Path, ) -> Result<(DeviceId, RawFd), SessionError>

Open a device the seat controls.

fn close_device(&mut self, id: DeviceId) -> Result<(), SessionError>

Close one this session opened.

fn acknowledge_pause(&mut self) -> Result<(), SessionError>

Tell the seat the pause has been acted on.

fn switch_session(&mut self, session: i32) -> Result<(), SessionError>

Ask to switch to another session, by VT number.

fn poll_fd(&self) -> Option<RawFd>

A descriptor that becomes readable when the seat has something to say.

fn dispatch( &mut self, timeout_ms: i32, events: &mut Vec<RawEvent>, ) -> Result<(), SessionError>

Let the seat deliver whatever it has, appending to events.

impl Debug for LibseatBackend

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for LibseatBackend

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.