Enum TaskState 

pub enum TaskState {
    Pending,
    Received,
    Reserved,
    Running,
    Retrying(u32),
    Succeeded(Vec<u8>),
    Failed(String),
    Revoked,
    Rejected,
    Custom {
        name: String,
        metadata: Option<Vec<u8>>,
    },
}

Task state enumeration with strict state machine transitions

Variants

Pending

Task is queued but not yet picked up by a worker

Received

Task has been received by a worker

Reserved

Task has been reserved by a worker but not yet executed

Running

Task is currently being executed

Retrying(u32)

Task is being retried (includes retry count)

Succeeded(Vec<u8>)

Task completed successfully with result

Failed(String)

Task failed with error message

Revoked

Task has been revoked

Rejected

Task has been rejected

Custom

Custom user-defined state with optional metadata

Fields

name: String

Custom state name

metadata: Option<Vec<u8>>

Optional custom metadata as JSON bytes

Implementations

impl TaskState

pub const fn is_terminal(&self) -> bool

Check if the task is in a terminal state

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

Create a custom state with a name

pub fn custom_with_metadata(name: impl Into<String>, metadata: Vec<u8>) -> Self

Create a custom state with name and JSON metadata

pub const fn is_custom(&self) -> bool

Check if this is a custom state

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

Get the custom state name if this is a custom state

pub fn custom_metadata(&self) -> Option<&[u8]>

Get the custom state metadata if this is a custom state with metadata

pub const fn is_revoked(&self) -> bool

Check if the task is revoked

pub const fn is_rejected(&self) -> bool

Check if the task is rejected

pub const fn is_received(&self) -> bool

Check if the task is received

pub const fn can_retry(&self, max_retries: u32) -> bool

Check if the task can be retried

pub const fn retry_count(&self) -> u32

Get the retry count

pub const fn is_active(&self) -> bool

Check if the task is in an active (non-terminal) state

pub const fn is_pending(&self) -> bool

Check if the task is pending

pub const fn is_reserved(&self) -> bool

Check if the task is reserved

pub const fn is_running(&self) -> bool

Check if the task is running

pub const fn is_retrying(&self) -> bool

Check if the task is retrying

pub const fn is_succeeded(&self) -> bool

Check if the task succeeded

pub const fn is_failed(&self) -> bool

Check if the task failed

pub fn success_result(&self) -> Option<&[u8]>

Get the success result if the task succeeded

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

Get the error message if the task failed

impl TaskState

pub fn name(&self) -> &str

Get a short string representation of the state name

Trait Implementations

impl Clone for TaskState

fn clone(&self) -> TaskState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TaskState

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TaskState

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for TaskState

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

Formats the value using the given formatter.

impl PartialEq for TaskState

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

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 TaskState

impl StructuralPartialEq for TaskState