Struct Publisher 

pub struct Publisher { /* private fields */ }

A Publisher client for the Cloud Pub/Sub API.

A Publisher sends messages to a specific topic. It manages message batching and sending in a background task.

let publisher = Publisher::builder("projects/my-project/topics/my-topic").build().await?;
let message_id_future = publisher.publish(Message::new().set_data("Hello, World"));

Configuration

To configure Publisher use the with_* methods in the type returned by builder(). The default configuration should work for most applications. Common configuration changes include

• with_endpoint(): by default this client uses the global default endpoint (https://pubsub.googleapis.com). Applications using regional endpoints or running in restricted networks (e.g. a network configured override this default.
• with_credentials(): by default this client uses Application Default Credentials. Applications using custom authentication may need to override this default.

Pooling and Cloning

Publisher holds a connection pool internally, it is advised to create one and then reuse it. You do not need to wrap Publisher in an Rc or Arc to reuse it.

Implementations

impl Publisher

pub fn builder<T: Into<String>>(topic: T) -> PublisherBuilder

Returns a builder for Publisher.

Example

let publisher = Publisher::builder("projects/my-project/topics/topic").build().await?;

pub fn publish(&self, msg: Message) -> PublishFuture

Publishes a message to the topic.

When this method encounters a non-recoverable error publishing for an ordering key, it will pause publishing on all new messages on that ordering key. Any outstanding messages that have not yet been published may return an error.

let message_id = publisher.publish(Message::new().set_data("Hello, World")).await?;

pub async fn flush(&self)

Flushes all buffered messages across all ordering keys, sending them immediately.

let _handle = publisher.publish(Message::new().set_data("event"));
// Ensures the message above is sent without needing to track its future.
publisher.flush().await;

This method bypasses configured batching delays and returns only after all messages buffered at the time of the call have reached a terminal state (success or permanent failure).

Recommendations

• For most use cases, we recommend you .await the PublishFuture returned by publish to retrieve message IDs and handle specific errors.
• Use flush() as a convenience during application shutdown to ensure the client attempts to send all outstanding data.

pub fn resume_publish<T: Into<String>>(&self, ordering_key: T)

Resume accepting publish for a paused ordering key.

Publishing using an ordering key might be paused if an error is encountered while publishing, to prevent messages from being published out of order. If the ordering key is not currently paused, this function is a no-op.

Example

if let Err(_) = publisher.publish(Message::new().set_data("foo").set_ordering_key("bar")).await {
    // Error handling code can go here.
    publisher.resume_publish("bar");
}

Trait Implementations

impl Clone for Publisher

fn clone(&self) -> Publisher

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Publisher

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

Formats the value using the given formatter.