Skip to main content

loco_rs/config/
queue.rs

1use serde::{Deserialize, Serialize};
2
3use super::database::{db_connect_timeout, db_idle_timeout, db_max_conn, db_min_conn};
4
5#[derive(Debug, Clone, Deserialize, Serialize)]
6#[serde(tag = "kind")]
7#[non_exhaustive]
8pub enum QueueConfig {
9    /// Redis queue
10    Redis(RedisQueueConfig),
11    /// Postgres queue (requires `db-postgres` feature)
12    #[cfg(feature = "db-postgres")]
13    Postgres(PostgresQueueConfig),
14    /// Sqlite queue (requires `db-sqlite` feature)
15    #[cfg(feature = "db-sqlite")]
16    Sqlite(SqliteQueueConfig),
17}
18
19impl QueueConfig {
20    /// Whether this queue is configured to discard all jobs on startup,
21    /// whichever backend it uses.
22    #[must_use]
23    pub const fn dangerously_flush(&self) -> bool {
24        match self {
25            Self::Redis(config) => config.dangerously_flush,
26            #[cfg(feature = "db-postgres")]
27            Self::Postgres(config) => config.dangerously_flush,
28            #[cfg(feature = "db-sqlite")]
29            Self::Sqlite(config) => config.dangerously_flush,
30        }
31    }
32}
33
34#[derive(Debug, Clone, Deserialize, Serialize)]
35pub struct RedisQueueConfig {
36    pub uri: String,
37    #[serde(default)]
38    pub dangerously_flush: bool,
39
40    /// Custom queue names declaration. Useful to model priority queues.
41    /// First queue in list is more important.
42    pub queues: Option<Vec<String>>,
43
44    #[serde(default = "num_workers")]
45    pub num_workers: u32,
46
47    /// Opt-in visibility-timeout reaper. See [`ReaperConfig`].
48    #[serde(default)]
49    pub reaper: Option<ReaperConfig>,
50}
51
52#[derive(Debug, Clone, Deserialize, Serialize)]
53pub struct PostgresQueueConfig {
54    pub uri: String,
55
56    #[serde(default)]
57    pub dangerously_flush: bool,
58
59    #[serde(default)]
60    pub enable_logging: bool,
61
62    #[serde(default = "db_max_conn")]
63    pub max_connections: u32,
64
65    #[serde(default = "db_min_conn")]
66    pub min_connections: u32,
67
68    #[serde(default = "db_connect_timeout")]
69    pub connect_timeout: u64,
70
71    #[serde(default = "db_idle_timeout")]
72    pub idle_timeout: u64,
73
74    #[serde(default = "pgq_poll_interval")]
75    pub poll_interval_sec: u32,
76
77    #[serde(default = "num_workers")]
78    pub num_workers: u32,
79
80    /// Opt-in visibility-timeout reaper. See [`ReaperConfig`].
81    #[serde(default)]
82    pub reaper: Option<ReaperConfig>,
83
84    /// Opt-in deletion of finished jobs. See [`RetentionConfig`].
85    #[serde(default)]
86    pub retention: Option<RetentionConfig>,
87}
88
89#[derive(Debug, Clone, Deserialize, Serialize)]
90#[cfg(feature = "db-sqlite")]
91pub struct SqliteQueueConfig {
92    pub uri: String,
93
94    #[serde(default)]
95    pub dangerously_flush: bool,
96
97    #[serde(default)]
98    pub enable_logging: bool,
99
100    #[serde(default = "db_max_conn")]
101    pub max_connections: u32,
102
103    #[serde(default = "db_min_conn")]
104    pub min_connections: u32,
105
106    #[serde(default = "db_connect_timeout")]
107    pub connect_timeout: u64,
108
109    #[serde(default = "db_idle_timeout")]
110    pub idle_timeout: u64,
111
112    #[serde(default = "sqlt_poll_interval")]
113    pub poll_interval_sec: u32,
114
115    #[serde(default = "num_workers")]
116    pub num_workers: u32,
117
118    /// Opt-in visibility-timeout reaper. See [`ReaperConfig`].
119    #[serde(default)]
120    pub reaper: Option<ReaperConfig>,
121
122    /// Opt-in deletion of finished jobs. See [`RetentionConfig`].
123    #[serde(default)]
124    pub retention: Option<RetentionConfig>,
125    /// PRAGMAs merged over the production defaults on every queue connection.
126    /// See [`SqliteConfig`](super::SqliteConfig).
127    #[serde(default)]
128    pub pragmas: std::collections::BTreeMap<String, String>,
129}
130
131/// Configuration for an opt-in visibility-timeout reaper.
132///
133/// When set on a queue config, the queue provider spawns a background task
134/// that periodically requeues jobs stuck in `Processing` for longer than
135/// `age_minutes` (for example, because the worker that dequeued them
136/// crashed before completing or failing them). It reuses the same requeue
137/// logic as `cargo loco jobs requeue`.
138///
139/// This is entirely opt-in: leaving `reaper` unset (`None`, the default)
140/// keeps existing behavior unchanged and no background task is spawned.
141///
142/// ```yaml
143/// queue:
144///   kind: Postgres
145///   uri: "{{ get_env(name=\"LOCO_QUEUE_URL\", default=\"postgres://localhost:5432/loco_app\") }}"
146///   # Optional: automatically requeue jobs stuck in `processing` (e.g. after a worker crash).
147///   # reaper:
148///   #   age_minutes: 10
149///   #   interval_seconds: 60
150/// ```
151#[derive(Debug, Clone, Deserialize, Serialize)]
152pub struct ReaperConfig {
153    /// Requeue jobs that have been in the `processing` state for longer than
154    /// this many minutes.
155    pub age_minutes: i64,
156
157    /// How often, in seconds, the reaper sweeps for stale jobs.
158    #[serde(default = "default_reaper_interval_seconds")]
159    pub interval_seconds: u64,
160}
161
162/// Configuration for opt-in retention of finished jobs.
163///
164/// The Postgres and `SQLite` queues keep every finished job. When
165/// `retention` is set, the queue provider spawns a background task that
166/// periodically deletes jobs whose status is finished and whose
167/// `updated_at` (the moment they finished) is older than the age set for
168/// that status. A status left out is kept forever. `queued` and
169/// `processing` jobs have no setting and are never deleted.
170///
171/// Off unless set, so upgrading never deletes anyone's jobs.
172///
173/// ```yaml
174/// queue:
175///   kind: Postgres
176///   uri: "{{ get_env(name=\"LOCO_QUEUE_URL\", default=\"postgres://localhost:5432/loco_app\") }}"
177///   # retention:
178///   #   completed_days: 7
179///   #   cancelled_days: 7
180///   #   failed_days: 30
181///   #   interval_seconds: 3600
182/// ```
183#[derive(Debug, Clone, Default, Deserialize, Serialize)]
184pub struct RetentionConfig {
185    /// Delete `completed` jobs this many days after they completed.
186    #[serde(default)]
187    pub completed_days: Option<i64>,
188
189    /// Delete `cancelled` jobs this many days after they were cancelled.
190    #[serde(default)]
191    pub cancelled_days: Option<i64>,
192
193    /// Delete `failed` jobs this many days after they failed.
194    #[serde(default)]
195    pub failed_days: Option<i64>,
196
197    /// How often, in seconds, the sweep runs.
198    #[serde(default = "default_retention_interval_seconds")]
199    pub interval_seconds: u64,
200}
201
202impl RetentionConfig {
203    /// The finished statuses that have an age set, with that age in days.
204    #[must_use]
205    pub fn ages(&self) -> Vec<(crate::bgworker::JobStatus, i64)> {
206        use crate::bgworker::JobStatus;
207        [
208            (JobStatus::Completed, self.completed_days),
209            (JobStatus::Cancelled, self.cancelled_days),
210            (JobStatus::Failed, self.failed_days),
211        ]
212        .into_iter()
213        .filter_map(|(status, days)| days.map(|d| (status, d)))
214        .collect()
215    }
216}
217
218fn default_retention_interval_seconds() -> u64 {
219    3600
220}
221
222fn pgq_poll_interval() -> u32 {
223    1
224}
225
226#[cfg(feature = "db-sqlite")]
227fn sqlt_poll_interval() -> u32 {
228    1
229}
230
231fn num_workers() -> u32 {
232    2
233}
234
235fn default_reaper_interval_seconds() -> u64 {
236    60
237}