Struct Subscribe 

pub struct Subscribe { /* private fields */ }

Builder for the client::Subscriber::subscribe method.

Implementations

impl Subscribe

pub fn build(self) -> MessageStream

Creates a new stream to receive messages from the subscription.

Example

let mut stream = client
    .subscribe("projects/my-project/subscriptions/my-subscription")
    .build();
while let Some((m, h)) = stream.next().await.transpose()? {
    println!("Received message m={m:?}");
    h.ack();
}

Note that the underlying connection with the server is lazy-initialized. It is not established until MessageStream::next() is called.

pub fn set_max_lease<T: Into<Duration>>(self, v: T) -> Self

Sets the maximum lease deadline for a message.

Example

let stream = client.subscribe("projects/my-project/subscriptions/my-subscription")
    .set_max_lease(Duration::from_secs(3600))
    .build();

The client holds a message for at most this amount. After a message has been held for this long, the client will stop extending its lease.

The default value is 60 minutes. If it takes your application longer than 60 minutes to process a message, you should increase this value.

pub fn set_max_lease_extension<T: Into<Duration>>(self, v: T) -> Self

Sets the maximum duration to extend lease deadlines by.

Example

let stream = client.subscribe("projects/my-project/subscriptions/my-subscription")
    .set_max_lease_extension(Duration::from_secs(20))
    .build();

The client extends lease deadlines by at most this amount.

If the server does not hear back from the client within this deadline (e.g. if an application crashes), it will resend any unacknowledged messages to another subscriber.

Note that this value is independent of the ack deadline configured on the subscription.

The minimum deadline you can specify is 10 seconds. The maximum deadline you can specify is 10 minutes. The client clamps the supplied value to this range.

The default value is 60 seconds.

pub fn set_max_outstanding_messages<T: Into<i64>>(self, v: T) -> Self

Flow control settings for the maximum number of outstanding messages.

Example

let stream = client.subscribe("projects/my-project/subscriptions/my-subscription")
    .set_max_outstanding_messages(2000)
    .build();

The server will stop sending messages to a client when this many messages are outstanding (i.e. that have not been acked). The server resumes sending messages when the outstanding message count drops below this value.

The limit applies per-stream. It is not a global limit.

Use a value <= 0 to set no limit on the number of outstanding messages.

The default value is 1000 messages.

pub fn set_max_outstanding_bytes<T: Into<i64>>(self, v: T) -> Self

Flow control settings for the maximum number of outstanding bytes.

Example

const MIB: i64 = 1024 * 1024;
let stream = client.subscribe("projects/my-project/subscriptions/my-subscription")
    .set_max_outstanding_bytes(200 * MIB)
    .build();

The server will stop sending messages to a client when this many bytes of messages are outstanding (i.e. that have not been acked). The server resumes sending messages when the outstanding byte count drops below this value.

The limit applies per-stream. It is not a global limit.

Use a value <= 0 to set no limit on the number of outstanding bytes.

The default value is 100 MiB.

pub fn set_shutdown_behavior(self, v: ShutdownBehavior) -> Self

Sets the shutdown behavior for the stream.

Example

use google_cloud_pubsub::subscriber::ShutdownBehavior::NackImmediately;
let stream = client.subscribe("projects/my-project/subscriptions/my-subscription")
    .set_shutdown_behavior(NackImmediately)
    .build();

The default behavior is WaitForProcessing.