Struct Task 

pub struct Task {
    pub id: String,
    pub task_type: String,
    pub queue: String,
    pub payload: Vec<u8>,
    pub options: TaskOptions,
    pub status: TaskStatus,
    pub created_at: i64,
    pub enqueued_at: Option<i64>,
    pub processed_at: Option<i64>,
    pub retry_cnt: u32,
    pub last_error: Option<String>,
}

Task struct

Fields

id: String

Task ID (UUID)

task_type: String

Task type (for routing to different handlers)

queue: String

Queue name

payload: Vec<u8>

Task payload (serialized data)

options: TaskOptions

Task options

status: TaskStatus

Task status

created_at: i64

Creation time (Unix timestamp, seconds)

enqueued_at: Option<i64>

Enqueue time (Unix timestamp, seconds)

processed_at: Option<i64>

Processing start time (Unix timestamp, seconds)

retry_cnt: u32

Current retry count

last_error: Option<String>

Last error message

Implementations

impl Task

pub fn builder(task_type: impl Into<String>) -> TaskBuilder

Create a new task builder

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

Validate if the task is valid

pub fn description(&self) -> String

Get task description

pub fn can_retry(&self) -> bool

Check if the task can be retried

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

Calculate the next retry delay (exponential backoff)

pub fn payload_json<'a, T>(&'a self) -> Result<T>

where T: Deserialize<'a>,

Deserialize payload as JSON

Example

use rediq::Task;
use serde::Deserialize;

#[derive(Deserialize)]
struct EmailData {
    to: String,
    subject: String,
}

let data: EmailData = task.payload_json()?;

pub fn payload_msgpack<'a, T>(&'a self) -> Result<T>

where T: Deserialize<'a>,

Deserialize payload as MessagePack

Example

use rediq::Task;
use serde::Deserialize;

#[derive(Deserialize)]
struct EmailData {
    to: String,
    subject: String,
}

let data: EmailData = task.payload_msgpack()?;

Trait Implementations

impl Clone for Task

fn clone(&self) -> Task

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Task

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Task

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Task

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TaskProgressExt for Task

fn progress(&self) -> Option<ProgressContext>

Get the progress reporter for this task

fn progress_guard(&self) -> Option<ProgressGuard>

Create a progress guard for automatic cleanup

fn has_progress(&self) -> bool

Check if progress reporting is available