modo-rs 0.8.0

Rust web framework for small monolithic apps
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
93
94
95
96
97
98
99
100
101
102
103

use serde::Deserialize;

/// Top-level configuration for the job worker.
///
/// Deserializes from YAML under the `job` key. All fields have defaults so an
/// empty config block is valid.
///
/// # Defaults
///
/// | Field | Default |
/// |---|---|
/// | `poll_interval_secs` | `1` |
/// | `stale_threshold_secs` | `600` (10 min) |
/// | `stale_reaper_interval_secs` | `60` (1 min) |
/// | `drain_timeout_secs` | `30` |
/// | `queues` | one `"default"` queue with concurrency 4 |
/// | `cleanup` | enabled, 1 h interval, 72 h retention |
#[non_exhaustive]
#[derive(Debug, Clone, Deserialize)]
#[serde(default)]
pub struct JobConfig {
    /// How often the worker polls the database for new jobs, in seconds.
    pub poll_interval_secs: u64,
    /// Jobs stuck in `running` for longer than this many seconds are considered
    /// stale and reset to `pending` by the reaper.
    pub stale_threshold_secs: u64,
    /// How often the stale reaper runs, in seconds.
    pub stale_reaper_interval_secs: u64,
    /// Maximum time in seconds to wait for in-flight jobs to finish during
    /// graceful shutdown.
    pub drain_timeout_secs: u64,
    /// Queue definitions. Defaults to a single `"default"` queue.
    pub queues: Vec<QueueConfig>,
    /// Optional periodic cleanup of terminal jobs. Set to `None` to disable.
    pub cleanup: Option<CleanupConfig>,
    /// Separate SQLite database for the job queue. When set, the job worker
    /// uses this pool instead of the main application database, keeping
    /// job-queue writes from contending with app queries.
    pub database: Option<crate::db::Config>,
}

impl Default for JobConfig {
    fn default() -> Self {
        Self {
            poll_interval_secs: 1,
            stale_threshold_secs: 600,
            stale_reaper_interval_secs: 60,
            drain_timeout_secs: 30,
            queues: vec![QueueConfig::default()],
            cleanup: Some(CleanupConfig::default()),
            database: None,
        }
    }
}

/// Configuration for a single named queue.
#[non_exhaustive]
#[derive(Debug, Clone, Deserialize)]
pub struct QueueConfig {
    /// Queue name. Must match the `queue` field used when enqueuing jobs.
    pub name: String,
    /// Maximum number of jobs from this queue that run concurrently.
    /// Defaults to `4`.
    #[serde(default = "default_concurrency")]
    pub concurrency: u32,
}

fn default_concurrency() -> u32 {
    4
}

impl Default for QueueConfig {
    fn default() -> Self {
        Self {
            name: "default".to_string(),
            concurrency: 4,
        }
    }
}

/// Configuration for the periodic cleanup of terminal jobs.
///
/// Terminal jobs (status `completed`, `dead`, or `cancelled`) whose
/// `updated_at` is older than `retention_secs` are deleted from the database.
#[non_exhaustive]
#[derive(Debug, Clone, Deserialize)]
#[serde(default)]
pub struct CleanupConfig {
    /// How often the cleanup task runs, in seconds. Defaults to `3600` (1 h).
    pub interval_secs: u64,
    /// Jobs whose `updated_at` is older than this many seconds are deleted.
    /// Defaults to `259200` (72 h).
    pub retention_secs: u64,
}

impl Default for CleanupConfig {
    fn default() -> Self {
        Self {
            interval_secs: 3600,
            retention_secs: 259_200, // 72h
        }
    }
}