Planificateur de tâches Rust : aperçu des bibliothèques et exemples de code

Planificateur de tâches Rust : guide complet pour les développeurs

Les planificateurs de tâches sont une partie essentielle du développement moderne. Ils permettent d'automatiser l'exécution d'opérations routinières : nettoyage périodique du cache, envoi de notifications, synchronisation de données et bien plus encore. Dans l'écosystème Rust, il existe plusieurs bibliothèques puissantes pour implémenter des planificateurs. Dans cet article, nous allons analyser trois approches principales : cron, tokio-cron-scheduler et job_scheduler.

1. Planificateur de base avec la bibliothèque cron

La bibliothèque cron fournit des fonctionnalités minimalistes pour analyser les expressions cron et calculer l'heure de la prochaine exécution. Elle ne contient pas de boucle d'exécution intégrée, elle est donc souvent combinée avec tokio ou std::thread.

Installation :

[dependencies]cron = "0.12"chrono = "0.4"tokio = { version = "1", features = ["full"] }

Exemple de planificateur simple :

use cron::Schedule;use chrono::Utc;use std::str::FromStr;use std::thread;use std::time::Duration;

fn main() {    // Chaque minute    let expression = "0 * * * * *";    let schedule = Schedule::from_str(expression).unwrap();

    loop {        let now = Utc::now();        if let Some(next) = schedule.upcoming(Utc).next() {            let duration = next - now;            if duration.num_seconds() > 0 {                thread::sleep(Duration::from_secs(duration.num_seconds() as u64));            }            println!("[{}] Tâche exécutée !", Utc::now());        }    }}

Cette approche offre un contrôle total, mais nécessite une gestion manuelle de la boucle. Elle convient aux scénarios simples.

2. Planificateur asynchrone tokio-cron-scheduler

Pour les applications asynchrones modernes basées sur tokio, la bibliothèque tokio-cron-scheduler est idéale. Elle fournit un planificateur prêt à l'emploi avec prise en charge des plannings cron complexes, des jobs avec identifiants et des gestionnaires d'erreurs.

Installation :

[dependencies]tokio-cron-scheduler = "0.10"tokio = { version = "1", features = ["full"] }

Exemple avec deux tâches :

use tokio_cron_scheduler::{Job, JobScheduler};use std::sync::Arc;

#[tokio::main]async fn main() -> Result<(), Box<dyn std::error::Error>> {    let sched = JobScheduler::new().await?;

    // Tâche 1 : toutes les 5 secondes    let job1 = Job::new_async("*/5 * * * * *", |_uuid, _lock| {        Box::pin(async move {            println!("[Job1] Exécuté à {:?}", std::time::SystemTime::now());        })    })?;

    // Tâche 2 : chaque minute    let job2 = Job::new_async("0 * * * * *", |_uuid, _lock| {        Box::pin(async move {            println!("[Job2] Tâche minute");        })    })?;

    sched.add(job1).await?;    sched.add(job2).await?;    sched.start().await?;

    // Maintenir l'application en cours d'exécution    tokio::signal::ctrl_c().await?;    println!("Planificateur arrêté");    Ok(())}

Avantages : gestion automatique du temps, prise en charge de la suppression/mise en pause des tâches, exécution asynchrone sans blocage.

3. Planificateur simple job_scheduler

La bibliothèque job_scheduler est conçue pour une simplicité maximale. Elle ne nécessite pas de runtime asynchrone et convient aux utilitaires console ou à l'intégration dans des projets synchrones existants.

Installation :

[dependencies]job_scheduler = "1.2"chrono = "0.4"

Exemple :

use job_scheduler::{Job, JobScheduler};use std::time::Duration;

fn main() {    let mut sched = JobScheduler::new();

    sched.add(Job::new("1/10 * * * * *".parse().unwrap(), || {        println!("Exécution de la tâche toutes les