Enum Delay 

#[non_exhaustive]
pub enum Delay {
    DlxTtl {
        waiting_queue: Option<String>,
    },
    DelayedMessageExchange {
        exchange: Option<String>,
    },
}

How a subscription handles retry_after / nack_after delays.

Passed to RabbitQueue::delay. A waiting queue or a delayed exchange is infrastructure the user owns, so a subscription opts in explicitly.

Examples

use std::time::Duration;

use ruststream_lapin::prelude::*;
use serde::Deserialize;

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

// An unpaid order waits a minute in `orders.retry` on the broker, then comes back here.
#[subscriber(RabbitQueue::new("orders").delay(Delay::dlx_ttl()))]
async fn fulfil(order: &Order) -> HandlerOutcome {
    if !order.paid {
        return HandlerOutcome::retry_after(Duration::from_mins(1));
    }
    tracing::info!(order.id, "fulfilling");
    HandlerOutcome::ack()
}

fn app() -> RustStream {
    let broker = LapinBroker::new("amqp://localhost:5672").declare_topology(true);
    RustStream::new(AppInfo::new("orders", "0.1.0")).with_broker(broker, |b| {
        b.include(fulfil);
    })
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

DlxTtl

Route delayed redeliveries through a TTL waiting queue whose dead-letter target is the origin queue.

Mixed delays

A queue releases expired messages only from its head, classic and quorum queues alike, so a short-TTL message behind a long-TTL one waits for the long one. When delays vary widely, use one waiting queue per delay class (dlx_ttl_named), or the delayed-message-exchange plugin (Delay::plugin_dme, feature plugin-dme), where a short delay never waits behind a long one.

Fields

waiting_queue: Option<String>

The waiting queue name; None derives <origin>.retry.

DelayedMessageExchange

Route delayed redeliveries through the rabbitmq_delayed_message_exchange plugin: the message is re-published to an x-delayed-message exchange with an x-delay header, and the plugin releases it to the origin queue after the delay. Unlike a waiting queue, mixed delays do not block each other. Requires the plugin on the broker, so it is behind the plugin-dme feature.

Fields

exchange: Option<String>

The delayed-message exchange name; None derives <origin>.delay.

Implementations

impl Delay

pub const fn dlx_ttl() -> Self

A TTL waiting queue named <origin>.retry.

pub fn dlx_ttl_named(name: impl Into<String>) -> Self

A TTL waiting queue with an explicit name.

pub const fn plugin_dme() -> Self

A delayed-message-exchange named <origin>.delay.

pub fn plugin_dme_named(name: impl Into<String>) -> Self

A delayed-message-exchange with an explicit name (share one across queues if you like).

Trait Implementations

impl Clone for Delay

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Delay

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

Formats the value using the given formatter.

impl Eq for Delay

impl PartialEq for Delay

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Delay