Struct MessageOptions 

pub struct MessageOptions {
    pub priority: Option<Priority>,
    pub ttl: Option<Duration>,
    pub expires_at: Option<u64>,
    pub delay: Option<Duration>,
    pub correlation_id: Option<String>,
    pub reply_to: Option<String>,
    pub headers: HashMap<String, String>,
    pub sign: bool,
    pub signing_key: Option<Vec<u8>>,
    pub encrypt: bool,
    pub encryption_key: Option<Vec<u8>>,
    pub compress: bool,
}

Message-level options

Examples

use celers_kombu::{MessageOptions, Priority};
use std::time::Duration;

let options = MessageOptions::new()
    .with_priority(Priority::High)
    .with_ttl(Duration::from_secs(3600))
    .with_correlation_id("req-123".to_string())
    .with_reply_to("response_queue".to_string());

assert_eq!(options.priority, Some(Priority::High));
assert_eq!(options.ttl, Some(Duration::from_secs(3600)));
assert_eq!(options.correlation_id, Some("req-123".to_string()));

// Check if message should be signed
let secure_options = MessageOptions::new()
    .with_signing(b"secret-key".to_vec());
assert!(secure_options.should_sign());

Fields

priority: Option<Priority>

Message priority

ttl: Option<Duration>

Message TTL (time-to-live)

expires_at: Option<u64>

Message expiration timestamp (absolute)

delay: Option<Duration>

Delay before message becomes visible

correlation_id: Option<String>

Correlation ID for request/response patterns

reply_to: Option<String>

Reply-to queue for RPC patterns

headers: HashMap<String, String>

Custom headers

sign: bool

Enable message signing (HMAC)

signing_key: Option<Vec<u8>>

Signing key for HMAC (if signing is enabled)

encrypt: bool

Enable message encryption (AES-256-GCM)

encryption_key: Option<Vec<u8>>

Encryption key (32 bytes for AES-256)

compress: bool

Compression hint

Implementations

impl MessageOptions

pub fn new() -> Self

Create new message options

pub fn with_priority(self, priority: Priority) -> Self

Set priority

pub fn with_ttl(self, ttl: Duration) -> Self

Set TTL

pub fn with_expires_at(self, timestamp: u64) -> Self

Set expiration timestamp (Unix timestamp in seconds)

pub fn with_delay(self, delay: Duration) -> Self

Set delay

pub fn with_correlation_id(self, id: impl Into<String>) -> Self

Set correlation ID

pub fn with_reply_to(self, queue: impl Into<String>) -> Self

Set reply-to queue

pub fn with_header( self, key: impl Into<String>, value: impl Into<String>, ) -> Self

Add a custom header

pub fn with_signing(self, key: Vec<u8>) -> Self

Enable message signing with HMAC

pub fn with_encryption(self, key: Vec<u8>) -> Self

Enable message encryption with AES-256-GCM

pub fn with_compression(self) -> Self

Enable compression

pub fn is_expired(&self, current_timestamp: u64) -> bool

Check if message has expired (based on expires_at)

pub fn should_delay(&self) -> bool

Check if message should be delayed

pub fn should_sign(&self) -> bool

Check if message should be signed

pub fn should_encrypt(&self) -> bool

Check if message should be encrypted

pub fn should_compress(&self) -> bool

Check if message should be compressed

Trait Implementations

impl Clone for MessageOptions

fn clone(&self) -> MessageOptions

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MessageOptions

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

Formats the value using the given formatter.

impl Default for MessageOptions

fn default() -> MessageOptions

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for MessageOptions

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for MessageOptions

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

where __S: Serializer,

Serialize this value into the given Serde serializer.