Struct PublisherBuilder 

pub struct PublisherBuilder { /* private fields */ }

A builder for a Publisher.

Implementations

impl PublisherBuilder

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

Creates a new Publisher from the builder’s configuration.

pub fn set_message_count_threshold(self, threshold: u32) -> PublisherBuilder

Sets the message count threshold for batching.

The publisher will send a batch of messages when the number of messages in the batch reaches this threshold.

Example

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

pub fn set_byte_threshold(self, threshold: u32) -> PublisherBuilder

Sets the byte threshold for batching.

The publisher will send a batch of messages when the total size of the messages in the batch reaches this threshold.

Example

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

pub fn set_delay_threshold(self, threshold: Duration) -> PublisherBuilder

Sets the delay threshold for batching.

The publisher will wait a maximum of this amount of time before sending a batch of messages.

Example

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

pub fn with_endpoint<V: Into<String>>(self, v: V) -> Self

Sets the endpoint.

let client = Publisher::builder("projects/my-project/topics/my-topic")
    .with_endpoint("http://private.googleapis.com")
    .build().await?;

pub fn with_tracing(self) -> Self

Enables tracing.

The client libraries can be dynamically instrumented with the Tokio tracing framework. Setting this flag enables this instrumentation.

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

pub fn with_credentials<T: Into<Credentials>>(self, v: T) -> Self

Configure the authentication credentials.

Most Google Cloud services require authentication, though some services allow for anonymous access, and some services provide emulators where no authentication is required. More information about valid credentials types can be found in the google-cloud-auth crate documentation.

use google_cloud_auth::credentials::mds;
let client = Publisher::builder("projects/my-project/topics/my-topic")
    .with_credentials(
        mds::Builder::default()
            .with_scopes(["https://www.googleapis.com/auth/cloud-platform.read-only"])
            .build()?)
    .build().await?;

pub fn with_retry_policy<V: Into<RetryPolicyArg>>(self, v: V) -> Self

Configure the retry policy.

The client libraries can automatically retry operations that fail. The retry policy controls what errors are considered retryable, sets limits on the number of attempts or the time trying to make attempts.

use google_cloud_gax::retry_policy::RetryPolicyExt;
use google_cloud_pubsub::retry_policy::RetryableErrors;
let client = Publisher::builder("projects/my-project/topics/my-topic")
    .with_retry_policy(RetryableErrors.with_attempt_limit(3))
    .build().await?;

pub fn with_backoff_policy<V: Into<BackoffPolicyArg>>(self, v: V) -> Self

Configure the retry backoff policy.

The client libraries can automatically retry operations that fail. The backoff policy controls how long to wait in between retry attempts.

use google_cloud_gax::exponential_backoff::ExponentialBackoff;
use std::time::Duration;
let policy = ExponentialBackoff::default();
let client = Publisher::builder("projects/my-project/topics/my-topic")
    .with_backoff_policy(policy)
    .build()
    .await?;

pub fn with_retry_throttler<V: Into<RetryThrottlerArg>>(self, v: V) -> Self

Configure the retry throttler.

Advanced applications may want to configure a retry throttler to Address Cascading Failures and when Handling Overload conditions. The client libraries throttle their retry loop, using a policy to control the throttling algorithm. Use this method to fine tune or customize the default retry throttler.

use google_cloud_gax::retry_throttler::AdaptiveThrottler;
let client = Publisher::builder("projects/my-project/topics/my-topic")
    .with_retry_throttler(AdaptiveThrottler::default())
    .build().await?;

pub fn with_grpc_subchannel_count(self, v: usize) -> Self

Configure the number of gRPC subchannels.

Example

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

gRPC-based clients may exhibit high latency if many requests need to be demuxed over a single HTTP/2 connection (often called a subchannel in gRPC).

Consider using more subchannels if your application makes many concurrent requests. Consider using fewer subchannels if your application needs the file descriptors for other purposes.

Trait Implementations

impl Clone for PublisherBuilder

fn clone(&self) -> PublisherBuilder

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PublisherBuilder

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

Formats the value using the given formatter.