rjob 0.1.2

A Simple Job Scheduler By Rust.
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use std::time::Duration;
use reqwest::{Method};
use tokio_cron::{Job, Scheduler};
use crate::configure::get_jobs;

use crate::models::http_job::HttpJob;
use crate::utils::datetime_util::{get_local_datetime_in_timezone};
use crate::utils::uuid_util::generate_uuid_without_hyphens;

/// Starts the cron scheduler for executing HTTP jobs.
///
/// This function retrieves the HTTP jobs using the `get_http_jobs` function and schedules them
/// based on their cron expressions. Only enabled jobs are scheduled for execution.
///
/// # Examples
///
/// ```rust
/// use tokio::runtime::Runtime;
///
/// let rt = Runtime::new().unwrap();
/// rt.block_on(async {
///     start_cron_scheduler().await;
/// });
/// ```
pub async fn start_cron_scheduler() {
    let jobs = get_jobs();
    let http_jobs = &jobs.http_jobs;

    let mut scheduler = Scheduler::new_in_timezone(jobs.timezone);

    for it in http_jobs {
        if it.enable {
            let job = Job::new_sync(&it.cron, move || {
                tokio::spawn(start_http_job(it));
            });
            scheduler.add(job);
        }
    }
}

/// Asynchronously starts an HTTP job by sending an HTTP request.
///
/// # Arguments
///
/// * `http_job` - An `Arc`-wrapped `HttpJob` struct representing the job to be started.
///
/// # Examples
///
/// ```rust
/// use std::sync::Arc;
///
/// let http_job = Arc::new(HttpJob {
///     name: "Test job".to_string(),
///     enable: true,
///     cron: "*/5 * * * * * *".to_string(),
///     request: HttpJobRequest {
///         method: "GET".to_string(),
///         url: "https://www.google.com".to_string(),
///         headers: None,
///         body: None
///     }
/// });
///
/// start_http_job(http_job).await;
/// ```
async fn start_http_job(http_job: &HttpJob) {
    let jobs = get_jobs();
    let timezone = &jobs.timezone;
    let uuid = generate_uuid_without_hyphens();
    let local_time = get_local_datetime_in_timezone(timezone);

    println!("{} {} Http job start, job name: {}", uuid, local_time, &http_job.name);
    println!("{} {} Job: [{}]", uuid, local_time, &http_job);

    let request = &http_job.request;
    let method = get_method(&request.method);
    let timeout = http_job.timeout.clone();

    let client = reqwest::Client::builder()
        .user_agent("rjob")
        .timeout(Duration::from_millis(timeout))
        .build()
        .expect("Failed to create HTTP client");

    let mut attempts = 0;
    let max_attempts = http_job.max_retry.clone();

    while attempts < max_attempts {
        attempts += 1;

        let request_builder = client.request(method.clone(), &request.url)
            .header("Content-Type", "application/json")
            .headers(request.headers.clone().unwrap_or_default())
            .body(request.body.clone().unwrap_or_default());

        let resp = match request_builder.send().await {
            Ok(resp) => resp,
            Err(err) => {
                println!("{} {} Http request failed, job name: {}, error: {}. Retry attempt: {}/{}", uuid, local_time, &http_job.name, err, attempts, max_attempts);
                continue;
            }
        };

        let status = resp.status();
        let text = resp.text().await.unwrap();

        if status.is_success() {
            println!("{} {} Http request success, job name: {}", uuid, local_time, &http_job.name);
            println!("{} {} Http response: {}", uuid, local_time, text);
        } else {
            println!("{} {} Http request failed, job name: {}, http status: {}", uuid, local_time, &http_job.name, status.as_u16());
            println!("{} {} Http response: {}", uuid, local_time, text);
        }
        break;
    }

    println!("{} {} Http job end, job name: {}\n", uuid, local_time, &http_job.name);
}

/// Get the corresponding `Method` enum value for the given HTTP method string.
///
/// # Arguments
///
/// * `method` - The HTTP method as a string.
///
/// # Returns
///
/// The corresponding `Method` enum value. If the provided method is not recognized,
/// the default value `Method::GET` is returned.
///
/// # Examples
///
/// ```
/// let method = get_method("POST");
/// println!("HTTP method: {:?}", method);
/// ```
fn get_method(method: &str) -> Method {
    match method.to_lowercase().as_str() {
        "get" => Method::GET,
        "post" => Method::POST,
        "put" => Method::PUT,
        "patch" => Method::PATCH,
        "options" => Method::OPTIONS,
        "delete" => Method::DELETE,
        "head" => Method::HEAD,
        _ => Method::GET
    }
}