Struct async_nats::jetstream::message::Acker

source ·
pub struct Acker { /* private fields */ }
Expand description

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

Implementations§

source§

impl Acker

source

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

source

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?;
}
source

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?;
}
source

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?;
}

Auto Trait Implementations§

§

impl !Freeze for Acker

§

impl !RefUnwindSafe for Acker

§

impl Send for Acker

§

impl Sync for Acker

§

impl Unpin for Acker

§

impl !UnwindSafe for Acker

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T> Instrument for T

source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> Same for T

source§

type Output = T

Should always be Self
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

source§

fn vzip(self) -> V

source§

impl<T> WithSubscriber for T

source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more
source§

impl<T> ErasedDestructor for T
where T: 'static,

source§

impl<T> MaybeSendSync for T