Struct TaskBuilder 

pub struct TaskBuilder { /* private fields */ }

Builder for configuring scheduled tasks with a fluent API

This builder is returned by Schedule::call() and allows you to configure when and how a closure-based task should run.

Example

schedule.call(|| async {
    println!("Running task!");
    Ok(())
})
.daily()
.at("03:00")
.name("daily-task")
.description("Runs every day at 3 AM");

Implementations

impl TaskBuilder

pub fn new<F>(f: F) -> Self

where F: Fn() -> BoxedFuture<'static> + Send + Sync + 'static,

Create a new task builder with a closure

The closure should return a future that resolves to Result<(), FrameworkError>.

pub fn from_async<F, Fut>(f: F) -> Self

where F: Fn() -> Fut + Send + Sync + 'static, Fut: Future<Output = TaskResult> + Send + 'static,

Create a TaskBuilder from an async closure

This is a convenience method that wraps the async closure properly.

pub fn from_task<T: Task + 'static>(task: T) -> Self

Create a TaskBuilder from a struct implementing the Task trait

This allows using the fluent schedule API with struct-based tasks.

Example

schedule.add(
    schedule.task(CleanupLogsTask::new())
        .daily()
        .at("03:00")
        .name("cleanup:logs")
);

pub fn cron(self, expression: &str) -> Self

Set a custom cron expression

Example

.cron("0 */5 * * *") // Every 5 hours at minute 0

Panics

Panics if the cron expression is invalid.

pub fn try_cron(self, expression: &str) -> Result<Self, String>

Try to set a custom cron expression, returning an error if invalid

pub fn every_minute(self) -> Self

Run every minute

pub fn every_two_minutes(self) -> Self

Run every 2 minutes

pub fn every_five_minutes(self) -> Self

Run every 5 minutes

pub fn every_ten_minutes(self) -> Self

Run every 10 minutes

pub fn every_fifteen_minutes(self) -> Self

Run every 15 minutes

pub fn every_thirty_minutes(self) -> Self

Run every 30 minutes

pub fn hourly(self) -> Self

Run every hour at minute 0

pub fn hourly_at(self, minute: u32) -> Self

Run every hour at a specific minute

Example

.hourly_at(30) // Every hour at XX:30

pub fn every_two_hours(self) -> Self

Run every 2 hours

pub fn every_three_hours(self) -> Self

Run every 3 hours

pub fn every_four_hours(self) -> Self

Run every 4 hours

pub fn every_six_hours(self) -> Self

Run every 6 hours

pub fn daily(self) -> Self

Run once daily at midnight

pub fn daily_at(self, time: &str) -> Self

Run daily at a specific time

Example

.daily_at("13:00") // Daily at 1:00 PM

pub fn twice_daily(self, first_hour: u32, second_hour: u32) -> Self

Run twice daily at specific times

Example

.twice_daily(1, 13) // At 1:00 AM and 1:00 PM

pub fn at(self, time: &str) -> Self

Set the time for the current schedule

This can be chained with other methods to set a specific time.

Example

.daily().at("14:30") // Daily at 2:30 PM
.weekly().at("09:00") // Weekly at 9:00 AM

pub fn weekly(self) -> Self

Run once weekly on Sunday at midnight

pub fn weekly_on(self, day: DayOfWeek) -> Self

Run weekly on a specific day at midnight

Example

.weekly_on(DayOfWeek::Monday)

pub fn days(self, days: &[DayOfWeek]) -> Self

Run on specific days of the week at midnight

Example

.days(&[DayOfWeek::Monday, DayOfWeek::Wednesday, DayOfWeek::Friday])

pub fn weekdays(self) -> Self

Run on weekdays (Monday-Friday) at midnight

pub fn weekends(self) -> Self

Run on weekends (Saturday-Sunday) at midnight

pub fn sundays(self) -> Self

Run on Sundays at midnight

pub fn mondays(self) -> Self

Run on Mondays at midnight

pub fn tuesdays(self) -> Self

Run on Tuesdays at midnight

pub fn wednesdays(self) -> Self

Run on Wednesdays at midnight

pub fn thursdays(self) -> Self

Run on Thursdays at midnight

pub fn fridays(self) -> Self

Run on Fridays at midnight

pub fn saturdays(self) -> Self

Run on Saturdays at midnight

pub fn monthly(self) -> Self

Run once monthly on the first day at midnight

pub fn monthly_on(self, day: u32) -> Self

Run monthly on a specific day at midnight

Example

.monthly_on(15) // On the 15th of each month

pub fn quarterly(self) -> Self

Run quarterly on the first day of each quarter at midnight

pub fn yearly(self) -> Self

Run yearly on January 1st at midnight

pub fn name(self, name: &str) -> Self

Set a name for this task

The name is used in logs and when listing scheduled tasks.

pub fn description(self, desc: &str) -> Self

Set a description for this task

The description is shown when listing scheduled tasks.

pub fn without_overlapping(self) -> Self

Prevent overlapping task runs

When enabled, the scheduler will skip running this task if a previous run is still in progress.

pub fn run_in_background(self) -> Self

Run task in background (non-blocking)

When enabled, the scheduler won’t wait for the task to complete before continuing to the next task.