qrush 2.1.1

Lightweight Job Queue and Task Scheduler for Rust (Actix/Axum + Redis + Cron)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

// crates/qrush/src/services/cron_service.rs
//
// Framework-neutral cron dashboard handlers. See `metrics_service` for the
// design: parsed inputs in, `DashboardResponse` out; the Actix/Axum adapters
// handle extraction and conversion.

use serde::Deserialize;
use tera::Context;
use crate::cron::cron_scheduler::CronScheduler;
use crate::services::http_response::DashboardResponse;
use crate::services::template_service::render_template;

#[derive(Deserialize)]
pub struct CronActionRequest {
    pub action: String,
    pub job_id: String,
    pub enabled: Option<bool>,
}

#[derive(Deserialize)]
pub struct CreateCronJobRequest {
    pub name: String,
    pub queue: String,
    pub cron_expression: String,
    pub job_type: String,
    pub payload: serde_json::Value,
}

pub async fn render_cron_jobs() -> DashboardResponse {
    match CronScheduler::list_cron_jobs().await {
        Ok(cron_jobs) => {
            let mut ctx = Context::new();
            ctx.insert("title", "Cron Jobs");
            ctx.insert("cron_jobs", &cron_jobs);
            render_template("cron_jobs.html.tera", ctx).await
        }
        Err(e) => {
            tracing::error!("Failed to fetch cron jobs: {:?}", e);
            DashboardResponse::text(500, "Failed to fetch cron jobs")
        }
    }
}

pub async fn cron_action(payload: CronActionRequest) -> DashboardResponse {
    let action = &payload.action;
    let job_id = &payload.job_id;

    let result = match action.as_str() {
        "toggle" => {
            let enabled = payload.enabled.unwrap_or(true);
            CronScheduler::toggle_cron_job(job_id, enabled).await
        }
        "delete" => {
            CronScheduler::delete_cron_job(job_id).await
        }
        "run_now" => {
            match CronScheduler::run_now(job_id).await {
                Ok(enqueued_id) => {
                    return DashboardResponse::json(&serde_json::json!({
                        "status": "success",
                        "action": "run_now",
                        "enqueued_job_id": enqueued_id
                    }));
                }
                Err(e) => Err(e)
            }
        }
        _ => {
            return DashboardResponse::json_status(400, &serde_json::json!({
                "error": "Invalid action"
            }));
        }
    };

    match result {
        Ok(_) => DashboardResponse::json(&serde_json::json!({
            "status": "success",
            "action": action
        })),
        Err(e) => DashboardResponse::json_status(500, &serde_json::json!({
            "error": e.to_string()
        }))
    }
}

pub async fn create_cron_job(_payload: CreateCronJobRequest) -> DashboardResponse {
    // This would need to be implemented based on your job registry
    // For now, return a placeholder response
    DashboardResponse::json(&serde_json::json!({
        "status": "Cron job creation endpoint - implement based on your job types"
    }))
}