Struct Bus 

pub struct Bus { /* private fields */ }

An authenticated connection to the session bus, past Hello.

Implementations

impl Bus

Methods over a connection.

pub fn connect(socket: &Path, wait: Duration) -> Result<Bus, CallError>

What: Connects to the bus socket, authenticates as the current user and says Hello, all within wait. Why: The deadline of the whole exchange starts here, so every later call shares what is left of it.

In TS you’d write (pseudocode):

const bus = await Bus.connect(path, 20000)

pub fn within(&mut self, wait: Duration)

What: Gives the calls that follow wait from now, replacing what was left of the time the connection was given. Why: The time of the connection bounds a stuck bus, but a caller that spends time between calls (waiting for a service to stop) must bound each phase by its own budget: a slow phase must not make the next one fail, and a query must not run past the phase it belongs to.

In TS you’d write (pseudocode):

bus.within(10000) // the next calls may take ten seconds in all

pub fn call( &mut self, target: &Target<'_>, arguments: &[&str], ) -> Result<Reply, CallError>

What: Makes one method call and waits for the reply that answers it, skipping the signals the bus sends meanwhile. Why: A return is the receiver’s confirmation (a reload returns after the units are read); an error reply comes back with its name and text so the caller can say what to do.

In TS you’d write (pseudocode):

await bus.call(RELOAD, [])

pub fn reload(&mut self) -> Result<(), CallError>

Reloads the user manager’s unit files.

pub fn reset_failed(&mut self, name: &str) -> Result<(), CallError>

Clears a unit’s failed state and its start-rate counter, so a start is not refused as “repeated too quickly”.

pub fn stop_unit(&mut self, name: &str) -> Result<(), CallError>

Stops a unit, replacing a queued job for it.

pub fn active_state(&mut self, name: &str) -> Result<Option<String>, CallError>

What: The unit’s ActiveState (active, activating, deactivating, inactive, failed), or nothing when the manager does not hold the unit. Why: A stop call returns when the job is queued, so only this state says the unit and its processes are gone. GetUnit answers the unit’s object path and the property read answers a variant holding the state text. A unit that is not loaded, or that unloads between the two calls, is not running.

In TS you’d write (pseudocode):

await bus.activeState('cli-git.service') // 'deactivating' | 'inactive' | undefined

pub fn start_unit(&mut self, name: &str) -> Result<(), CallError>

Starts a unit, replacing a queued job for it.

Trait Implementations

impl Manager for Bus

fn within(&mut self, wait: Duration)

Gives the calls that follow wait from now in all, so that each phase of provisioning has a time of its own.

fn reload(&mut self) -> Result<(), CallError>

Reloads the unit files.

fn reset_failed(&mut self, unit: &str) -> Result<(), CallError>

Clears a unit’s failed state and start-rate counter.

fn start(&mut self, unit: &str) -> Result<(), CallError>

Starts a unit.

fn stop(&mut self, unit: &str) -> Result<(), CallError>

Stops a unit.

fn active_state(&mut self, unit: &str) -> Result<Option<String>, CallError>

The unit’s state as the manager reports it (active, deactivating, inactive, failed), or nothing when the manager holds no such unit.