Enum DelayStrategy 

pub enum DelayStrategy {
    TTL,
    DelayedExchange,
}

Strategy for delaying retry messages

TTL (Time-To-Live) Strategy

Uses RabbitMQ’s TTL feature with temporary retry queues. Messages are published to temporary queues that expire and route to the original queue. Pros: No plugin required, simple setup Cons: Less precise timing, requires queue cleanup

DelayedExchange Strategy

Uses the RabbitMQ delayed message exchange plugin (requires x-delayed-message plugin). Messages are published to a delay exchange with x-delay header. The exchange automatically routes messages after the delay period. Pros: More precise, cleaner architecture, single exchange Cons: Requires RabbitMQ plugin installation

Example

use rust_rabbit::retry::{DelayStrategy, RetryConfig, RetryMechanism};
use std::time::Duration;

// Using TTL strategy (default, no plugin required)
let config = RetryConfig {
    max_retries: 3,
    mechanism: RetryMechanism::Exponential {
        base_delay: Duration::from_secs(1),
        max_delay: Duration::from_secs(60),
    },
    delay_strategy: DelayStrategy::TTL,
    dead_letter_exchange: None,
    dead_letter_queue: None,
};

// Using RabbitMQ delayed exchange plugin (requires plugin)
let config = RetryConfig {
    max_retries: 3,
    mechanism: RetryMechanism::Linear { delay: Duration::from_secs(5) },
    delay_strategy: DelayStrategy::DelayedExchange,
    dead_letter_exchange: None,
    dead_letter_queue: None,
};

Variants

TTL

TTL-based delays using temporary queues (no plugin required)

DelayedExchange

RabbitMQ delayed message exchange plugin (requires x-delayed-message plugin)

Trait Implementations

impl Clone for DelayStrategy

fn clone(&self) -> DelayStrategy

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DelayStrategy

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

Formats the value using the given formatter.

impl Default for DelayStrategy

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for DelayStrategy

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for DelayStrategy

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for DelayStrategy