Enum NatsMessage 

pub enum NatsMessage {
    Core(Box<CoreMessage>),
    JetStream(Box<JetStreamMessage>),
}

A NATS delivery. Two flavours: core NATS (no ack) and JetStream (real ack/nack/redelivery).

Both variants are boxed to keep the enum compact; the wrapped async_nats messages are large.

Variants

Core(Box<CoreMessage>)

A core NATS subject delivery. Acknowledgement is not supported.

JetStream(Box<JetStreamMessage>)

A JetStream pull-consumer delivery with full ack support.

Trait Implementations

impl BuildContext<NatsMessage> for JetStreamContext

fn build(msg: &NatsMessage) -> Self

Builds the context value by reading fields out of msg.

impl Debug for NatsMessage

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

Formats the value using the given formatter.

impl IncomingMessage for NatsMessage

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

The PARTITION_KEY_HEADER value the sender set, which the runtime’s keyed worker lanes (workers(n, by_key)) order by.

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

How many times the server has delivered this message, counting this one.

A JetStream consumer keeps that count and reports it on every delivery, so a cap declared at the mount site counts the server’s own redeliveries - an ack_wait that ran out, a negative acknowledgement - and not only the copies this process published. Core NATS neither stores a message nor redelivers one, so a core delivery has no count and the framework’s retry-count header is the whole tally.

fn supports_nack_after(&self) -> bool

Whether this delivery can honor a native delayed redelivery.

true for every JetStream delivery: the protocol carries the delay in the negative acknowledgement itself, so no opt-in infrastructure is needed. Core NATS has no acknowledgement at all, so a core delivery reports false and the runtime applies its broker-agnostic deferred re-publish instead.

async fn nack_after(self, delay: Duration) -> Result<(), AckError>

Redelivers this message no sooner than delay, natively: JetStream’s negative acknowledgement takes the delay as its argument (-NAK {"delay": ns}), so the server holds the message for that long and then redelivers it on this consumer. Nothing is re-published and no copy is made, so the delivery count, the stream sequence, and the payload all stay the ones the message was first delivered with.

Errors

Returns AckError::Unsupported on a core (non-JetStream) delivery, and AckError::Broker when the acknowledgement cannot be sent.

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 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 NatsMessage

Partitioned lets the workers(N, by_key) runtime feature assign a dispatch lane based on a well-known message header. NATS has no native partition concept, so the key travels as the PARTITION_KEY_HEADER header value and the sender is responsible for setting it.

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

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