Struct Acker

pub struct Acker { /* private fields */ }

A lightweight struct useful for decoupling message contents and the ability to ack it.

Implementations

impl Acker

pub fn new(context: Context, reply: Option<Subject>) -> Self

pub async fn ack(&self) -> Result<(), Error>

Acknowledges a message delivery by sending +ACK to the server.

If AckPolicy is set to All or Explicit, messages has to be acked. Otherwise redeliveries will occur and Consumer will not be able to advance.

Examples

use async_nats::jetstream::consumer::PullConsumer;
use async_nats::jetstream::Message;
use futures::StreamExt;
let client = async_nats::connect("localhost:4222").await?;
let jetstream = async_nats::jetstream::new(client);

let consumer: PullConsumer = jetstream
    .get_stream("events")
    .await?
    .get_consumer("pull")
    .await?;

let mut messages = consumer.fetch().max_messages(100).messages().await?;

while let Some(message) = messages.next().await {
    let (message, acker) = message.map(Message::split)?;
    // Do something with the message. Ownership can be taken over `Message`
    // while retaining ability to ack later.
    println!("message: {:?}", message);
    // Ack it. `Message` may be dropped already.
    acker.ack().await?;
}

pub async fn ack_with(&self, kind: AckKind) -> Result<(), Error>

Acknowledges a message delivery by sending a chosen AckKind variant to the server.

Examples

use async_nats::jetstream::consumer::PullConsumer;
use async_nats::jetstream::AckKind;
use async_nats::jetstream::Message;
use futures::StreamExt;
let client = async_nats::connect("localhost:4222").await?;
let jetstream = async_nats::jetstream::new(client);

let consumer: PullConsumer = jetstream
    .get_stream("events")
    .await?
    .get_consumer("pull")
    .await?;

let mut messages = consumer.fetch().max_messages(100).messages().await?;

while let Some(message) = messages.next().await {
    let (message, acker) = message.map(Message::split)?;
    // Do something with the message. Ownership can be taken over `Message`.
    // while retaining ability to ack later.
    println!("message: {:?}", message);
    // Ack it. `Message` may be dropped already.
    acker.ack_with(AckKind::Nak(None)).await?;
}

pub async fn double_ack(&self) -> Result<(), Error>

Acknowledges a message delivery by sending +ACK to the server and awaits for confirmation for the server that it received the message. Useful if user wants to ensure exactly once semantics.

If AckPolicy is set to All or Explicit, messages has to be acked. Otherwise redeliveries will occur and Consumer will not be able to advance.

Examples

use async_nats::jetstream::Message;
use futures::StreamExt;
let client = async_nats::connect("localhost:4222").await?;
let jetstream = async_nats::jetstream::new(client);

let consumer = jetstream
    .get_stream("events")
    .await?
    .get_consumer("pull")
    .await?;

let mut messages = consumer.fetch().max_messages(100).messages().await?;

while let Some(message) = messages.next().await {
    let (message, acker) = message.map(Message::split)?;
    // Do something with the message. Ownership can be taken over `Message`.
    // while retaining ability to ack later.
    println!("message: {:?}", message);
    // Ack it. `Message` may be dropped already.
    acker.double_ack().await?;
}