Struct Schedule 

pub struct Schedule { /* private fields */ }

Schedule - main entry point for scheduling tasks

Provides methods for registering and running scheduled tasks. Tasks can be registered via trait implementations or closures.

Example

use ferro_rs::Schedule;

pub fn register(schedule: &mut Schedule) {
    // Register a struct implementing Task trait
    schedule.add(
        schedule.task(MyCleanupTask::new())
            .daily()
            .at("03:00")
            .name("cleanup")
    );

    // Or use a closure
    schedule.add(
        schedule.call(|| async {
            println!("Hello!");
            Ok(())
        }).daily().at("03:00").name("greeting")
    );
}

Implementations

impl Schedule

pub fn new() -> Self

Create a new empty schedule

pub fn task<T: Task + 'static>(&self, task: T) -> TaskBuilder

Register a trait-based scheduled task

Returns a TaskBuilder that allows fluent schedule configuration.

Example

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

pub fn call<F, Fut>(&mut self, f: F) -> TaskBuilder

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

Register a closure-based scheduled task

Returns a TaskBuilder that allows you to configure the schedule using a fluent API.

Example

schedule.call(|| async {
    // Task logic here
    Ok(())
}).daily().at("03:00").name("my-task");

pub fn add(&mut self, builder: TaskBuilder) -> &mut Self

Add a configured task builder to the schedule

This method is typically called after configuring a task with call().

Example

let builder = schedule.call(|| async { Ok(()) }).daily();
schedule.add(builder);

pub fn tasks(&self) -> &[TaskEntry]

Get all registered tasks

pub fn len(&self) -> usize

Get the number of registered tasks

pub fn is_empty(&self) -> bool

Check if there are no registered tasks

pub fn due_tasks(&self) -> Vec<&TaskEntry>

Get tasks that are due to run now

pub async fn run_due_tasks(&self) -> Vec<(&str, Result<(), FrameworkError>)>

Run all due tasks once

Returns a vector of results for each task that was run.

pub async fn run_all_tasks(&self) -> Vec<(&str, Result<(), FrameworkError>)>

Run all tasks regardless of their schedule

Useful for testing or manual triggering.

pub fn find(&self, name: &str) -> Option<&TaskEntry>

Find a task by name

pub async fn run_task(&self, name: &str) -> Option<Result<(), FrameworkError>>

Run a specific task by name

Trait Implementations

impl Default for Schedule

fn default() -> Self

Returns the “default value” for a type.