Struct zbus::ConnectionBuilder

pub struct ConnectionBuilder<'a> { /* fields omitted */ }

A builder for zbus::Connection.

Implementations

impl<'a> ConnectionBuilder<'a>

pub fn session() -> Result<Self>

Create a builder for the session/user message bus connection.

pub fn system() -> Result<Self>

Create a builder for the system-wide message bus connection.

pub fn address<A>(address: A) -> Result<Self> where
    A: TryInto<Address>,
    A::Error: Into<Error>, 

Create a builder for connection that will use the given D-Bus bus address.

pub fn unix_stream(stream: UnixStream) -> Self

Create a builder for connection that will use the given unix stream.

pub fn socket<S: Socket + 'static>(socket: S) -> Self

Create a builder for connection that will use the given socket.

pub fn p2p(self) -> Self

The to-be-created connection will be a peer-to-peer connection.

pub fn server(self, guid: &'a Guid) -> Self

The to-be-created connection will be a server using the given GUID.

The to-be-created connection will wait for incoming client authentication handshake and negotiation messages, for peer-to-peer communications after successful creation.

pub fn max_queued(self, max: usize) -> Self

Set the max number of messages to queue.

Since typically you’d want to set this at instantiation time, you can set it through the builder.

Example

let conn = ConnectionBuilder::session()?
    .max_queued(30)
    .build()
    .await?;
assert_eq!(conn.max_queued(), 30);

// Do something useful with `conn`..

pub fn internal_executor(self, enabled: bool) -> Self

Enable or disable the internal executor thread.

The thread is enabled by default.

See Connection::executor for more details.

pub fn serve_at<P, I>(self, path: P, iface: I) -> Result<Self> where
    I: Interface,
    P: TryInto<ObjectPath<'a>>,
    P::Error: Into<Error>, 

Register a D-Bus Interface to be served at a given path.

This is similar to zbus::ObjectServer::at, except that it allows you to have your interfaces available immediately after the connection is established. Typically, this is exactly what you’d want. Also in contrast to zbus::ObjectServer::at, this method will replace any previously added interface with the same name at the same path.

pub fn name<W>(self, well_known_name: W) -> Result<Self> where
    W: TryInto<WellKnownName<'a>>,
    W::Error: Into<Error>, 

Register a well-known name for this connection on the bus.

This is similar to zbus::Connection::request_name, except the name is requested as part of the connection setup (ConnectionBuilder::build), immediately after interfaces registered (through ConnectionBuilder::serve_at) are advertised. Typically this is exactly what you want.

pub async fn build(self) -> Result<Connection>

Build the connection, consuming the builder.

Errors

Until server-side bus connection is supported, attempting to build such a connection will result in Error::Unsupported error.

Trait Implementations

impl<'a> Debug for ConnectionBuilder<'a>

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

Formats the value using the given formatter.