Enum Settle 

pub enum Settle {
    AtLeastOnce,
    AtMostOnce,
}

Delivery guarantee of a subscription, set with AmqpAddress::settle.

Under AtLeastOnce the handler’s outcome is the delivery’s disposition, and the runtime caps the attempts: AMQP 1.0 declares no node with a delivery limit and a dead-letter address, so max_attempts and dead_letter read the same here as on every broker.

Examples

Five deliveries per order, then the orders.dead address. An order that is not ready yet comes back in half a minute, through a retry publisher that stamps each copy:

use std::time::Duration;

use ruststream::runtime::{Outgoing, PublishContext};
use ruststream_amqp::prelude::*;
use serde::Deserialize;

#[derive(Deserialize)]
struct Order {
    id: u64,
}

#[subscriber(AmqpAddress::queue("orders").settle(Settle::AtLeastOnce))]
async fn fulfil(order: &Order) -> HandlerOutcome {
    if order.id == 0 {
        // Not ready yet: ask for the delivery again in half a minute.
        return HandlerOutcome::retry_after(Duration::from_secs(30));
    }
    tracing::info!(order.id, "fulfilled");
    HandlerOutcome::ack()
}

/// Stamps a deferred copy with the address it came from, so a redelivery is recognisable.
struct Retried;

impl<C, Options> PublishTransform<ForReply<C>, Options> for Retried {
    type Destination = Reads;

    fn apply(
        &self,
        out: &mut Outgoing<'_>,
        _options: &mut Option<Options>,
        cx: &PublishContext<'_, C>,
    ) {
        out.headers_mut()
            .insert("x-retried-from", cx.name().to_owned());
    }
}

#[ruststream::app]
fn app() -> impl App {
    RustStream::new(AppInfo::new("orders", "0.1.0")).with_broker(
        AmqpBroker::new("amqp://artemis:artemis@localhost:5672"),
        |b| {
            b.include(fulfil)
                .max_attempts(nonzero!(5u32))
                .dead_letter("orders.dead")
                .out_retry(Publish)
                .transform(Retried);
        },
    )
}

Variants

AtLeastOnce

Deliveries are settled by the handler. The default.

ack sends accepted. A retry, nack(true), sends modified with delivery-failed, never released, so the broker counts the attempt in delivery-count. A drop, nack(false), sends rejected, and the broker’s dead-letter policy decides what follows.

AtMostOnce

Deliveries are settled on receipt, so a message is gone whether the handler finished or not; ack and nack report AckError::Unsupported.

Trait Implementations

impl Clone for Settle

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Settle

impl Debug for Settle

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

Formats the value using the given formatter.

impl Default for Settle

fn default() -> Self

Returns the “default value” for a type.

impl Eq for Settle

impl PartialEq for Settle

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Settle