Create and open a D-Bus connection from a UnixStream.

The connection may either be set up for a bus connection, or not (for peer-to-peer communications).

Upon successful return, the connection is fully established and negotiated: D-Bus messages can be sent and received.

Create a server Connection for the given UnixStream and the server guid.

The connection will wait for incoming client authentication handshake & negotiation messages, for peer-to-peer communications.

Upon successful return, the connection is fully established and negotiated: D-Bus messages can be sent and received.

Get a stream to receive incoming messages.

Get a sink to send out messages.

Send msg to the peer.

Unlike MessageSink, this method sets a unique (to this connection) serial number on the message before sending it off, for you.

On successfully sending off msg, the assigned serial number is returned.

Send a method call.

Create a method-call message, send it over the connection, then wait for the reply.

On successful reply, an Ok(Message) is returned. On error, an Err is returned. D-Bus error replies are returned as Error::MethodError.

Emit a signal.

Create a signal message, and send it over the connection.

Reply to a message.

Given an existing message (likely a method call), send a reply back to the caller with the given body.

Returns the message serial number.

Reply an error to a message.

Given an existing message (likely a method call), send an error reply back to the caller with the given error_name and body.

Returns the message serial number.

Checks if self is a connection to a message bus.

This will return false for p2p connections.

Assigns a serial number to msg that is unique to this connection.

This method can fail if msg is corrupt.

The unique name as assigned by the message bus or None if not a message bus connection.

Max number of messages to queue.

Set the max number of messages to queue.

Since typically you’d want to set this at instantiation time, this method takes ownership of self and returns an owned Connection instance so you can use the builder pattern to set the value.

Example

let conn = Connection::new_session()
    .await?
    .set_max_queued(30);
assert_eq!(conn.max_queued(), 30);

// Do something useful with `conn`..

The server’s GUID.

The underlying executor.

This method is available when built with the default internal-executor feature disabled. Since zbus will not spawn thread internally to run the executor in this case, you’re responsible to continuously tick the executor. Failure to do so will result in hangs.

Examples

Here is how one would typically run the zbus executor through tokio’s single-threaded scheduler:

use zbus::azync::Connection;
use tokio::runtime;

runtime::Builder::new_current_thread()
       .build()
       .unwrap()
       .block_on(async {
    let conn = Connection::new_session().await.unwrap();
    {
       let conn = conn.clone();
       tokio::task::spawn(async move {
           loop {
               conn.executor().tick().await;
           }
       });
    }

    // All your other async code goes here.
});

Get the raw file descriptor of this connection.

Create a Connection to the session/user message bus.

Create a Connection to the system-wide message bus.

Create a Connection for the given D-Bus address.