Struct PubSubMessage 

pub struct PubSubMessage { /* private fields */ }

A message delivered by a PubSubSubscriber.

ack and nack(requeue = true) are native. nack(requeue = false) acknowledges: Pub/Sub has no “drop without redelivery” beyond acknowledgement - dead-lettering is the subscription’s dead-letter policy, driven by repeated nacks and expired deadlines, not a per-message verb. The exception is the last delivery that policy allows, where a rejection is exactly how the message reaches the dead-letter topic; a delivery there is rejected rather than acknowledged. The policy is the one the subscription carries when it opens, declared at the mount site or set by an operator. On an exactly-once subscription the confirmed forms are used, so Ok from ack means the broker accepted it.

Trait Implementations

impl Debug for PubSubMessage

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

Formats the value using the given formatter.

impl IncomingMessage for PubSubMessage

fn redelivery_count(&self) -> Option<u64>

The delivery attempt the service reports, counting this delivery.

Pub/Sub sends it only where the subscription has a dead-letter policy, so a subscription without one reports no count. It is the only count a delivery of this crate carries: nothing here publishes a retry copy, so the framework’s own header never appears beside it, and the cap the count would be read against is the subscription’s to apply.

fn supports_nack_after(&self) -> bool

Pub/Sub has no delayed nack of its own, so this crate holds the delivery instead. The client keeps extending the ack deadline of a delivery nothing has settled, which is what makes holding one a real delay rather than a lost message.

fn nack_after( self, delay: Duration, ) -> impl Future<Output = Result<(), AckError>> + Send

Holds the delivery for delay, then rejects it so the subscription redelivers.

The delivery stays leased while it is held: the client extends its ack deadline in the background for as long as nothing has settled it, up to GooglePubSub::max_lease. The wait runs on a task of its own, so the subscription keeps dispatching; the delivery counts against the subscription’s outstanding messages until it comes back, which is what it does against the service too.

If the process dies while a delivery is held, the lease stops being extended and the subscription redelivers on its own once it expires. The delay is lost there, not the message.

Errors

Returns AckError::Broker carrying PubSubError::DelayBeyondLease when delay outlives the subscription’s maximum lease, because the delivery would come back before it elapsed. The check is at the call because a handler names the delay while it runs.

fn payload(&self) -> &[u8]

Returns the raw payload of the message.

fn headers(&self) -> &HeaderMap

Returns the headers attached to the message.

async fn ack(self) -> Result<(), AckError>

Acknowledges successful processing. Consumes the message handle.

async fn nack(self, requeue: bool) -> Result<(), AckError>

Negatively acknowledges the message. When requeue is true the broker should redeliver according to its own retry policy; when false it should drop or dead-letter the message.

fn partition_key(&self) -> Option<&[u8]>

Returns the routing key the broker partitioned this message by, or None when the message carries no key.

fn decode_error(&self) -> Option<&CodecError>

The error the broker met while reading this delivery, or None when it read the delivery whole.

impl Partitioned for PubSubMessage

fn partition_key(&self) -> Option<&[u8]>

Returns the partition key for this item, or None if the broker should pick a partition.