Attribute Macro task 

#[task]

A procedural macro for generating a Task from a function.

If the annotated function has a return value, the return value must be a TaskResult<R>.

Parameters

• name: The name to use when registering the task. Should be unique. If not given the name will be set to the name of the function being decorated.
• time_limit: Set a task-level TaskOptions::time_limit.
• hard_time_limit: Set a task-level TaskOptions::hard_time_limit.
• max_retries: Set a task-level TaskOptions::max_retries.
• min_retry_delay: Set a task-level TaskOptions::min_retry_delay.
• max_retry_delay: Set a task-level TaskOptions::max_retry_delay.
• retry_for_unexpected: Set a task-level TaskOptions::retry_for_unexpected.
• acks_late: Set a task-level TaskOptions::acks_late.
• content_type: Set a task-level TaskOptions::content_type.
• bind: A bool. If true, the task will be run like an instance method and so the function’s first argument should be a reference to Self. Note however that Rust won’t allow you to call the argument self. Instead, you could use task or just t.
• on_failure: An async callback function to run when the task fails. Should accept a reference to a task instance and a reference to a TaskError.
• on_success: An async callback function to run when the task succeeds. Should accept a reference to a task instance and a reference to the value returned by the task.

For more information see the tasks chapter in the Rusty Celery Book.

Examples

Create a task named add with all of the default options:

use celery::prelude::*;

#[celery::task]
fn add(x: i32, y: i32) -> TaskResult<i32> {
    Ok(x + y)
}

Use a name different from the function name:

#[celery::task(name = "sum")]
fn add(x: i32, y: i32) -> TaskResult<i32> {
    Ok(x + y)
}

Customize the default retry behavior:

#[celery::task(
    time_limit = 3,
    max_retries = 100,
    min_retry_delay = 1,
    max_retry_delay = 60,
)]
async fn io_task() -> TaskResult<()> {
    // Do some async IO work that could possible fail, such as an HTTP request...
    Ok(())
}

Bind the function to the task instance so it runs like an instance method:

#[celery::task(bind = true)]
fn bound_task(task: &Self) {
    println!("Hello, World! From {}", task.name());
}

Run custom callbacks on failure and on success:

#[celery::task(on_failure = failure_callback, on_success = success_callback)]
fn task_with_callbacks() {}

async fn failure_callback<T: Task>(task: &T, err: &TaskError) {
    println!("{} failed with {:?}", task.name(), err);
}

async fn success_callback<T: Task>(task: &T, ret: &T::Returns) {
    println!("{} succeeded: {:?}", task.name(), ret);
}