Struct Message 

pub struct Message {
    pub headers: MessageHeaders,
    pub properties: MessageProperties,
    pub body: Vec<u8>,
    pub content_type: String,
    pub content_encoding: String,
}

Complete Celery message

Fields

headers: MessageHeaders

Message headers

properties: MessageProperties

Message properties

body: Vec<u8>

Serialized body (task arguments)

content_type: String

Content type

content_encoding: String

Content encoding

Implementations

impl Message

pub fn new(task: String, id: Uuid, body: Vec<u8>) -> Self

Create a new message with JSON body

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

Set priority (0-9)

pub fn with_parent(self, parent_id: Uuid) -> Self

Set parent task ID

pub fn with_root(self, root_id: Uuid) -> Self

Set root task ID

pub fn with_group(self, group: Uuid) -> Self

Set group ID

pub fn with_eta(self, eta: DateTime<Utc>) -> Self

Set ETA (delayed execution)

pub fn with_expires(self, expires: DateTime<Utc>) -> Self

Set expiration

pub fn with_retries(self, retries: u32) -> Self

Set retry count

pub fn with_correlation_id(self, correlation_id: String) -> Self

Set correlation ID (for RPC-style calls)

pub fn with_reply_to(self, reply_to: String) -> Self

Set reply-to queue (for results)

pub fn with_delivery_mode(self, mode: u8) -> Self

Set delivery mode (1 = non-persistent, 2 = persistent)

pub fn validate(&self) -> Result<(), ValidationError>

Validate the complete message

Validates:

• Headers (task name, retries, eta/expires)
• Properties (delivery mode, priority)
• Content type format
• Body size

pub fn validate_with_limit( &self, max_body_bytes: usize, ) -> Result<(), ValidationError>

Validate with custom body size limit

pub fn has_eta(&self) -> bool

Check if the message has an ETA (delayed execution)

pub fn has_expires(&self) -> bool

Check if the message has an expiration time

pub fn has_group(&self) -> bool

Check if the message is part of a group

pub fn has_parent(&self) -> bool

Check if the message has a parent task

pub fn has_root(&self) -> bool

Check if the message has a root task

pub fn is_persistent(&self) -> bool

Check if the message is persistent

pub fn task_id(&self) -> Uuid

Get the task ID

pub fn task_name(&self) -> &str

Get the task name

pub fn content_type_str(&self) -> &str

Get the content type as a string slice

pub fn content_encoding_str(&self) -> &str

Get the content encoding as a string slice

pub fn body_size(&self) -> usize

Get the message body size in bytes

pub fn has_empty_body(&self) -> bool

Check if the message body is empty

pub fn retry_count(&self) -> u32

Get the retry count (0 if not set)

pub fn priority(&self) -> Option<u8>

Get the priority (None if not set)

pub fn has_correlation_id(&self) -> bool

Check if message has a correlation ID

pub fn correlation_id(&self) -> Option<&str>

Get the correlation ID

pub fn reply_to(&self) -> Option<&str>

Get the reply-to queue

pub fn is_workflow_message(&self) -> bool

Check if this is a workflow message (has parent, root, or group)

pub fn with_new_id(&self) -> Self

Clone the message with a new task ID

pub fn to_builder(&self) -> MessageBuilder

Create a builder from this message (for modification)

Note: This creates a new builder with the message’s metadata. The body (args/kwargs) must be set separately on the builder.

pub fn is_ready_for_execution(&self) -> bool

Check if the message is ready for immediate execution (not delayed)

pub fn is_not_expired(&self) -> bool

Check if the message has not expired yet

pub fn should_process(&self) -> bool

Check if the message should be processed (not expired and ready for execution)

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

Set ETA to now + duration (builder pattern)

Examples

use celers_protocol::Message;
use uuid::Uuid;
use chrono::Duration;

let msg = Message::new("task".to_string(), Uuid::new_v4(), vec![])
    .with_eta_delay(Duration::minutes(5));
assert!(msg.has_eta());

pub fn with_expires_in(self, duration: Duration) -> Self

Set expiration to now + duration (builder pattern)

Examples

use celers_protocol::Message;
use uuid::Uuid;
use chrono::Duration;

let msg = Message::new("task".to_string(), Uuid::new_v4(), vec![])
    .with_expires_in(Duration::hours(1));
assert!(msg.has_expires());

pub fn time_until_eta(&self) -> Option<Duration>

Get the time remaining until ETA (None if no ETA or already past)

pub fn time_until_expiration(&self) -> Option<Duration>

Get the time remaining until expiration (None if no expiration or already expired)

pub fn increment_retry(&mut self) -> u32

Increment the retry count (returns new count)

Trait Implementations

impl Clone for Message

fn clone(&self) -> Message

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Message

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Message

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Extend<Message> for MessageBatch

fn extend<T: IntoIterator<Item = Message>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl Extend<Message> for MessagePriorityQueue

fn extend<T: IntoIterator<Item = Message>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl Extend<Message> for MultiLevelQueue

fn extend<T: IntoIterator<Item = Message>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl FromIterator<Message> for MessageBatch

fn from_iter<T: IntoIterator<Item = Message>>(iter: T) -> Self

Creates a value from an iterator.

impl FromIterator<Message> for MessagePriorityQueue

fn from_iter<T: IntoIterator<Item = Message>>(iter: T) -> Self

Creates a value from an iterator.

impl FromIterator<Message> for MultiLevelQueue

fn from_iter<T: IntoIterator<Item = Message>>(iter: T) -> Self

Creates a value from an iterator.

impl MessageExt for Message

fn validate_basic(&self) -> Result<(), ExtensionError>

Validate basic message structure

fn is_expired(&self) -> bool

Check if message is expired

fn is_scheduled(&self) -> bool

Check if message is scheduled for future execution

fn get_age_seconds(&self) -> Option<i64>

Get message age in seconds

impl PartialEq for Message

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Message

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Message

impl StructuralPartialEq for Message