Struct Subscription 

pub struct Subscription { /* private fields */ }

Subscription is a reference to a PubSub subscription.

Implementations

impl Subscription

pub fn id(&self) -> String

id returns the unique identifier of the subscription within its project.

pub fn fully_qualified_name(&self) -> &str

fully_qualified_name returns the globally unique printable name of the subscription.

pub fn fully_qualified_snapshot_name(&self, id: &str) -> String

fully_qualified_snapshot_name returns the globally unique printable name of the snapshot.

pub fn get_client(&self) -> SubscriberClient

pub async fn create( &self, fqtn: &str, cfg: SubscriptionConfig, retry: Option<RetrySetting>, ) -> Result<(), Status>

create creates the subscription.

pub async fn delete(&self, retry: Option<RetrySetting>) -> Result<(), Status>

delete deletes the subscription.

pub async fn exists(&self, retry: Option<RetrySetting>) -> Result<bool, Status>

exists reports whether the subscription exists on the server.

pub async fn config( &self, retry: Option<RetrySetting>, ) -> Result<(String, SubscriptionConfig), Status>

config fetches the current configuration for the subscription.

pub async fn update( &self, updating: SubscriptionConfigToUpdate, retry: Option<RetrySetting>, ) -> Result<(String, SubscriptionConfig), Status>

update changes an existing subscription according to the fields set in updating. It returns the new SubscriptionConfig.

pub async fn pull( &self, max_messages: i32, retry: Option<RetrySetting>, ) -> Result<Vec<ReceivedMessage>, Status>

pull pulls messages from the server.

pub async fn subscribe( &self, opt: Option<SubscribeConfig>, ) -> Result<MessageStream, Status>

Subscribes to a Pub/Sub subscription and creates a MessageStream for consuming messages.

This method initializes a message stream by setting up the necessary channel and spawning subscriber tasks based on the provided configuration. It supports multiple subscribers and configurable channel capacity.

use google_cloud_gax::grpc::Status;
use google_cloud_pubsub::subscription::{SubscribeConfig, Subscription};
use futures_util::StreamExt;
use tokio::select;
use tokio_util::sync::CancellationToken;

async fn run(ctx: CancellationToken, subscription: Subscription) -> Result<(), Status> {
    // Start receiving messages from the subscription.
    let mut iter = subscription.subscribe(None).await?;
    // Get buffered messages.
    // To close safely, use a CancellationToken or to signal shutdown.
    while let Some(message) = tokio::select!{
        v = iter.next() => v,
        _ = ctx.cancelled() => None,
    } {
        let _ = message.ack().await;
    }
    // Wait for all the unprocessed messages to be Nack.
    // If you don't call dispose, the unprocessed messages will be Nack when the iterator is dropped.
    iter.dispose().await;
    Ok(())
 }

pub async fn ack(&self, ack_ids: Vec<String>) -> Result<(), Status>

Ack acknowledges the messages associated with the ack_ids in the AcknowledgeRequest. The Pub/Sub system can remove the relevant messages from the subscription. This method is for batch ack.

pub async fn seek( &self, to: SeekTo, retry: Option<RetrySetting>, ) -> Result<(), Status>

seek seeks the subscription a past timestamp or a saved snapshot.

pub async fn get_snapshot( &self, name: &str, retry: Option<RetrySetting>, ) -> Result<Snapshot, Status>

get_snapshot fetches an existing pubsub snapshot.

pub async fn create_snapshot( &self, name: &str, labels: HashMap<String, String>, retry: Option<RetrySetting>, ) -> Result<Snapshot, Status>

create_snapshot creates a new pubsub snapshot from the subscription’s state at the time of calling. The snapshot retains the messages for the topic the subscription is subscribed to, with the acknowledgment states consistent with the subscriptions. The created snapshot is guaranteed to retain:

• The message backlog on the subscription – or to be specific, messages that are unacknowledged at the time of the subscription’s creation.
• All messages published to the subscription’s topic after the snapshot’s creation. Snapshots have a finite lifetime – a maximum of 7 days from the time of creation, beyond which they are discarded and any messages being retained solely due to the snapshot dropped.

pub async fn delete_snapshot( &self, name: &str, retry: Option<RetrySetting>, ) -> Result<(), Status>

delete_snapshot deletes an existing pubsub snapshot.

Trait Implementations

impl Clone for Subscription

fn clone(&self) -> Subscription

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Subscription

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

Formats the value using the given formatter.