use chronographer::prelude::*; #[tokio::main] async fn main() { let task = Task::define( TaskScheduleInterval::from_secs(4), |_ctx| async { println!("Hello World"); Ok(()) } ); CHRONOGRAPHER_SCHEDULER.schedule_owned(task).await; loop {} // (Optional) keeps alive the program }

let payment_process = TaskFrameBuilder::builder(handle_payment) .with_timeout(Duration::from_secs(30)) // It cannot exceed 30 seconds .with_fallback(handle_payment_failure) // If it does or fails, execute this .with_instant_retry(NonZeroU32::new(3).unwrap()) // If all fail, retry 3 times .with_dependencies(vec![ LogicalDependency::or( system_notif_dependency, cleanup_notif_dependency ), data_extraction_task_dependency, validation_task_dependency, // ... ]) // Run the workflow only if dependencies are resolved .build(); let payment_task = Task::builder() .frame(payment_process) .schedule(TaskScheduleInterval::from_secs(3)) .schedule_strategy(CancelCurrentSchedulingPolicy) .build();

/*  A basic example for integration with Prometheus,  it involves defining the TaskHook as well as the events it supports */ struct PrometheusMetricsHook; /*  Defines what kind of event the PrometheusMetricsHook TaskHook implementation supports,  if you don't care which event the TaskHook is being used and the code is the same,  you can do:    impl<E: TaskHookEvent> TaskHook<E> for PrometheusMetricsHook {  ...  } */ impl TaskHook<OnTaskStart> for PrometheusMetricsHook { async fn on_event(&self, event: OnTaskStart, ctx: Arc<TaskContext>, payload: &OnTaskStart::Payload) { metrics::counter!("tasks_started_total", "task_id" => payload.task_id.to_string()).increment(1); metrics::gauge!("running_tasks").increment(1.0); } } impl TaskHook<OnTaskEnd> for PrometheusMetricsHook { async fn on_event(&self, event: OnTaskEnd, ctx: Arc<TaskContext>, payload: &OnTaskEnd::Payload) { metrics::gauge!("running_tasks").decrement(1.0); if payload.error.is_some() { metrics::counter!("tasks_failed_total", "task_id" => payload.task_id.to_string()).increment(1); } else { metrics::counter!("tasks_completed_total", "task_id" => payload.task_id.to_string()).increment(1); } } } impl TaskHook<OnTimeout> for PrometheusMetricsHook { async fn on_event(&self, event: OnTimeout, ctx: Arc<TaskContext>, payload: &OnTimeout::Payload) { // ...Executes when a TimeoutTaskFrame throws a timeout... } } impl TaskHook<OnHookAttach<OnTaskStart>> for PrometheusMetricsHook { async fn on_event( &self, event: OnHookAttach<OnTaskStart>, ctx: Arc<TaskContext>, payload: &OnHookAttach<OnTaskStart>::Payload ) { // ...You can initialize logic for when it is attached to a OnTaskStart event... } } /*  The second phase is actually attaching the hook to  the relevant events of a Task */ let hook = Arc::new(PrometheusMetricsHook); task.attach_hook::<OnTaskStart>(hook).await; task.attach_hook::<OnTimeout>(hook).await;

let schedule = TaskScheduleCalendar::builder() .millisecond(Arc::new(TaskCalendarFieldExact::new(0))) // At millisecond 0 .second(Arc::new(TaskCalendarFieldInterval::new(30))) // Every 30 seconds .minute(Arc::new(TaskCalendarFieldExact::new(0))) // At minute 0 .hour(Arc::new(TaskCalendarFieldRange::new(9..=17))) // Business hours only .build(); // Note: Currently TaskCalendarFieldRange does not exist, however, it will be added in the future

let critical_task = Task::builder() .frame(alert_system) .priority(TaskPriority::CRITICAL) // Jumps to front of queue .schedule(...) .build();

struct MyCoolScheduler(Scheduler); impl MyCoolScheduler { pub fn new(clock: impl SchedulerClock) -> Self { MyCoolScheduler( Scheduler::builder() .store(...) .clock(clock) .dispatcher(...) .build() ) } } // Testing the scheduler with a virtual clock #[cfg(test)] mod tests { use super::*; #[tokio::test] async fn test_scheduled_task() { let virtual_clock = Arc::new(VirtualClock::new()); let test_scheduler = MyCoolScheduler::new(virtual_clock.clone()); // Fast-forward time to test scheduling virtual_clock.advance(Duration::from_hours(24)).await; // ... } }