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(RedisQueueConfig),
11 #[cfg(feature = "db-postgres")]
13 Postgres(PostgresQueueConfig),
14 #[cfg(feature = "db-sqlite")]
16 Sqlite(SqliteQueueConfig),
17}
18
19impl QueueConfig {
20 #[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 pub queues: Option<Vec<String>>,
43
44 #[serde(default = "num_workers")]
45 pub num_workers: u32,
46
47 #[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 #[serde(default)]
82 pub reaper: Option<ReaperConfig>,
83
84 #[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 #[serde(default)]
120 pub reaper: Option<ReaperConfig>,
121
122 #[serde(default)]
124 pub retention: Option<RetentionConfig>,
125 #[serde(default)]
128 pub pragmas: std::collections::BTreeMap<String, String>,
129}
130
131#[derive(Debug, Clone, Deserialize, Serialize)]
152pub struct ReaperConfig {
153 pub age_minutes: i64,
156
157 #[serde(default = "default_reaper_interval_seconds")]
159 pub interval_seconds: u64,
160}
161
162#[derive(Debug, Clone, Default, Deserialize, Serialize)]
184pub struct RetentionConfig {
185 #[serde(default)]
187 pub completed_days: Option<i64>,
188
189 #[serde(default)]
191 pub cancelled_days: Option<i64>,
192
193 #[serde(default)]
195 pub failed_days: Option<i64>,
196
197 #[serde(default = "default_retention_interval_seconds")]
199 pub interval_seconds: u64,
200}
201
202impl RetentionConfig {
203 #[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}