Enum MessageState 

pub enum MessageState {
    Active,
    Deferred,
    Scheduled,
    DeadLettered,
    Completed,
    Abandoned,
}

Represents the current state of a message within Azure Service Bus.

This enum maps to Azure Service Bus message states and provides additional states for local message lifecycle management. Each state represents a specific point in the message processing lifecycle with different implications for message availability and processing.

State Transitions

Messages typically follow these state transitions:

┌─────────────────────────────────────────────────────────────┐
│                    Message Lifecycle                        │
└─────────────────────────────────────────────────────────────┘

          Enqueue
             │
             ▼
         ┌─────────┐     Defer      ┌──────────┐
         │ Active  │ ──────────────► │ Deferred │
         └─────────┘                 └──────────┘
             │                           │
             │ Complete                  │ Activate
             ▼                           ▼
       ┌───────────┐                 ┌─────────┐
       │ Completed │◄────────────────│ Active  │
       └───────────┘                 └─────────┘
             │                           │
             │                           │ Abandon/Retry Limit
             │                           ▼
             │                    ┌─────────────┐
             │                    │ Abandoned / │
             │                    │DeadLettered │
             │                    └─────────────┘
             │
         ┌───────────┐     Schedule     ┌───────────┐
         │ Scheduled │ ◄───────────────│   Active  │
         └───────────┘                 └───────────┘

Examples

Checking Message State

use quetty_server::model::MessageState;

let state = MessageState::Active;

match state {
    MessageState::Active => {
        println!("Message is available for immediate processing");
    }
    MessageState::Deferred => {
        println!("Message is deferred - can be activated later");
    }
    MessageState::Scheduled => {
        println!("Message is scheduled for future delivery");
    }
    MessageState::DeadLettered => {
        println!("Message failed processing and is in dead letter queue");
    }
    MessageState::Completed => {
        println!("Message processing completed successfully");
    }
    MessageState::Abandoned => {
        println!("Message processing was abandoned");
    }
}

State-Based Operations

use quetty_server::model::{MessageModel, MessageState};

fn can_process_message(message: &MessageModel) -> bool {
    matches!(message.state, MessageState::Active | MessageState::Deferred)
}

fn requires_attention(message: &MessageModel) -> bool {
    matches!(message.state, MessageState::DeadLettered | MessageState::Abandoned)
}

fn is_pending_delivery(message: &MessageModel) -> bool {
    matches!(message.state, MessageState::Scheduled)
}

// Usage
let message = get_message();
if can_process_message(&message) {
    println!("Message {} is ready for processing", message.id);
} else if requires_attention(&message) {
    println!("Message {} requires manual intervention", message.id);
}

UI Display Logic

use quetty_server::model::MessageState;

fn get_state_color(state: &MessageState) -> &'static str {
    match state {
        MessageState::Active => "green",
        MessageState::Deferred => "yellow",
        MessageState::Scheduled => "blue",
        MessageState::DeadLettered => "red",
        MessageState::Completed => "gray",
        MessageState::Abandoned => "orange",
    }
}

fn get_state_description(state: &MessageState) -> &'static str {
    match state {
        MessageState::Active => "Ready for processing",
        MessageState::Deferred => "Deferred for later",
        MessageState::Scheduled => "Scheduled delivery",
        MessageState::DeadLettered => "Failed processing",
        MessageState::Completed => "Processing complete",
        MessageState::Abandoned => "Processing abandoned",
    }
}

State Descriptions

• Active - Message is available in the queue for immediate processing
• Deferred - Message has been deferred and can be retrieved by sequence number
• Scheduled - Message is scheduled for delivery at a future time
• DeadLettered - Message exceeded retry limits or failed validation
• Completed - Message processing completed successfully
• Abandoned - Message processing was explicitly abandoned

Default State

The default state is Active, representing a newly enqueued message ready for processing.

Variants

Active

Message is available in the queue for immediate processing. This is the most common state for messages awaiting consumption.

Deferred

Message has been deferred by a receiver and can be retrieved later using its sequence number. Deferred messages don’t count toward the queue’s active message count.

Scheduled

Message is scheduled for delivery at a specific future time. It will automatically become Active when the scheduled time arrives.

DeadLettered

Message has been moved to the dead letter queue due to:

• Exceeding maximum delivery count
• Message TTL expiration
• Explicit dead lettering by receiver
• Message size limits or other validation failures

Completed

Message processing has been completed successfully. This is a terminal state - the message will be removed from the queue.

Abandoned

Message processing was abandoned by the receiver. The message may be retried or moved to dead letter queue depending on retry policies.

Trait Implementations

impl Clone for MessageState

fn clone(&self) -> MessageState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MessageState

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

Formats the value using the given formatter.

impl Default for MessageState

fn default() -> MessageState

Returns the “default value” for a type.

impl PartialEq for MessageState

fn eq(&self, other: &MessageState) -> 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 MessageState

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for MessageState