1use crate::{models::server_backup::ServerBackupKind, prelude::*};
2use serde::{Deserialize, Serialize};
3use sqlx::{Row, Type, postgres::PgRow};
4use std::{collections::BTreeMap, sync::LazyLock};
5use utoipa::ToSchema;
6
7#[derive(Debug, ToSchema, Serialize, Deserialize, Type, PartialEq, Eq, Hash, Clone, Copy)]
8#[serde(rename_all = "snake_case")]
9#[sqlx(
10 type_name = "system_backup_policy_run_target_status",
11 rename_all = "SCREAMING_SNAKE_CASE"
12)]
13pub enum SystemBackupPolicyRunTargetStatus {
14 Pending,
15 Dispatched,
16 Skipped,
17 Failed,
18}
19
20#[derive(Debug, ToSchema, Serialize, Deserialize, Type, PartialEq, Eq, Hash, Clone, Copy)]
21#[serde(rename_all = "snake_case")]
22#[sqlx(
23 type_name = "system_backup_policy_run_target_reason",
24 rename_all = "SCREAMING_SNAKE_CASE"
25)]
26pub enum SystemBackupPolicyRunTargetReason {
27 NodeMaintenance,
28 BackupConfigurationMaintenance,
29 DatabaseAgentHostMaintenance,
30 DatabaseInstanceStopped,
31 ServerBusy,
32 MetadataFailed,
33 NoBackupConfiguration,
34 UnsupportedBackupDisk,
35 TargetRemoved,
36 CreateFailed,
37 PolicyDisabled,
38 Superseded,
39 Cancelled,
40}
41
42#[derive(Serialize, Deserialize, Clone)]
43pub struct SystemBackupPolicyRunTarget {
44 pub uuid: uuid::Uuid,
45 pub server: Option<Fetchable<super::server::Server>>,
46 pub database_instance:
47 Option<Fetchable<super::server_database_instance::ServerDatabaseInstance>>,
48 pub database_instance_name: Option<compact_str::CompactString>,
49 pub server_backup: Option<Fetchable<super::server_backup::ServerBackup>>,
50 pub server_backup_successful: Option<bool>,
51 pub server_backup_completed: Option<chrono::NaiveDateTime>,
52
53 pub status: SystemBackupPolicyRunTargetStatus,
54 pub reason: Option<SystemBackupPolicyRunTargetReason>,
55
56 pub not_before: Option<chrono::NaiveDateTime>,
57 pub updated: chrono::NaiveDateTime,
58
59 extension_data: super::ModelExtensionData,
60}
61
62impl BaseModel for SystemBackupPolicyRunTarget {
63 const NAME: &'static str = "system_backup_policy_run_target";
64
65 fn get_extension_list() -> &'static super::ModelExtensionList {
66 static EXTENSIONS: LazyLock<super::ModelExtensionList> =
67 LazyLock::new(|| parking_lot::RwLock::new(Vec::new()));
68
69 &EXTENSIONS
70 }
71
72 fn get_extension_data(&self) -> &super::ModelExtensionData {
73 &self.extension_data
74 }
75
76 #[inline]
77 fn base_columns(prefix: Option<&str>) -> BTreeMap<&'static str, compact_str::CompactString> {
78 let prefix = prefix.unwrap_or_default();
79
80 BTreeMap::from([
81 (
82 "system_backup_policy_run_targets.uuid",
83 compact_str::format_compact!("{prefix}uuid"),
84 ),
85 (
86 "system_backup_policy_run_targets.server_uuid",
87 compact_str::format_compact!("{prefix}server_uuid"),
88 ),
89 (
90 "system_backup_policy_run_targets.database_instance_uuid",
91 compact_str::format_compact!("{prefix}database_instance_uuid"),
92 ),
93 (
94 "server_database_instances.name",
95 compact_str::format_compact!("{prefix}database_instance_name"),
96 ),
97 (
98 "system_backup_policy_run_targets.server_backup_uuid",
99 compact_str::format_compact!("{prefix}server_backup_uuid"),
100 ),
101 (
102 "server_backups.successful",
103 compact_str::format_compact!("{prefix}server_backup_successful"),
104 ),
105 (
106 "server_backups.completed",
107 compact_str::format_compact!("{prefix}server_backup_completed"),
108 ),
109 (
110 "system_backup_policy_run_targets.status",
111 compact_str::format_compact!("{prefix}status"),
112 ),
113 (
114 "system_backup_policy_run_targets.reason",
115 compact_str::format_compact!("{prefix}reason"),
116 ),
117 (
118 "system_backup_policy_run_targets.not_before",
119 compact_str::format_compact!("{prefix}not_before"),
120 ),
121 (
122 "system_backup_policy_run_targets.updated",
123 compact_str::format_compact!("{prefix}updated"),
124 ),
125 ])
126 }
127
128 #[inline]
129 fn map(prefix: Option<&str>, row: &PgRow) -> Result<Self, crate::database::DatabaseError> {
130 let prefix = prefix.unwrap_or_default();
131
132 Ok(Self {
133 uuid: row.try_get(compact_str::format_compact!("{prefix}uuid").as_str())?,
134 server: row
135 .try_get::<Option<uuid::Uuid>, _>(
136 compact_str::format_compact!("{prefix}server_uuid").as_str(),
137 )?
138 .map(super::server::Server::get_fetchable),
139 database_instance: row
140 .try_get::<Option<uuid::Uuid>, _>(
141 compact_str::format_compact!("{prefix}database_instance_uuid").as_str(),
142 )?
143 .map(super::server_database_instance::ServerDatabaseInstance::get_fetchable),
144 database_instance_name: row
145 .try_get(compact_str::format_compact!("{prefix}database_instance_name").as_str())?,
146 server_backup: row
147 .try_get::<Option<uuid::Uuid>, _>(
148 compact_str::format_compact!("{prefix}server_backup_uuid").as_str(),
149 )?
150 .map(super::server_backup::ServerBackup::get_fetchable),
151 server_backup_successful: row.try_get(
152 compact_str::format_compact!("{prefix}server_backup_successful").as_str(),
153 )?,
154 server_backup_completed: row.try_get(
155 compact_str::format_compact!("{prefix}server_backup_completed").as_str(),
156 )?,
157 status: row.try_get(compact_str::format_compact!("{prefix}status").as_str())?,
158 reason: row.try_get(compact_str::format_compact!("{prefix}reason").as_str())?,
159 not_before: row.try_get(compact_str::format_compact!("{prefix}not_before").as_str())?,
160 updated: row.try_get(compact_str::format_compact!("{prefix}updated").as_str())?,
161 extension_data: Self::map_extensions(prefix, row)?,
162 })
163 }
164}
165
166pub struct SystemBackupPolicyRunTargetClaim {
167 pub uuid: uuid::Uuid,
168 pub server: Option<Fetchable<super::server::Server>>,
169 pub database_instance:
170 Option<Fetchable<super::server_database_instance::ServerDatabaseInstance>>,
171 pub existing_server_backup: Option<Fetchable<super::server_backup::ServerBackup>>,
172}
173
174impl SystemBackupPolicyRunTarget {
175 pub async fn by_system_backup_policy_run_uuid_with_pagination(
176 database: &crate::database::Database,
177 system_backup_policy_run_uuid: uuid::Uuid,
178 status: Option<SystemBackupPolicyRunTargetStatus>,
179 page: i64,
180 per_page: i64,
181 search: Option<&str>,
182 ) -> Result<super::Pagination<Self>, crate::database::DatabaseError> {
183 super::PaginatedQueryBuilder::new(
184 Self::columns_sql(None),
185 format!(
186 r#"
187 FROM system_backup_policy_run_targets
188 LEFT JOIN servers ON servers.uuid = system_backup_policy_run_targets.server_uuid
189 LEFT JOIN server_database_instances ON server_database_instances.uuid = system_backup_policy_run_targets.database_instance_uuid
190 LEFT JOIN server_backups ON server_backups.uuid = system_backup_policy_run_targets.server_backup_uuid
191 WHERE
192 system_backup_policy_run_targets.system_backup_policy_run_uuid = $1
193 AND ($2::system_backup_policy_run_target_status IS NULL OR system_backup_policy_run_targets.status = $2)
194 AND {search}
195 "#,
196 search = super::search_sql(
197 3,
198 &["servers.name", "server_database_instances.name"],
199 &["servers.uuid", "server_database_instances.uuid"]
200 ),
201 ),
202 "system_backup_policy_run_targets.updated DESC, system_backup_policy_run_targets.uuid",
203 )
204 .bind(system_backup_policy_run_uuid)
205 .bind(status)
206 .bind(search)
207 .fetch(database, page, per_page)
208 .await
209 }
210
211 pub async fn claimable(
212 database: &crate::database::Database,
213 system_backup_policy_uuid: uuid::Uuid,
214 kind: ServerBackupKind,
215 parallelism: i32,
216 limit: i64,
217 ) -> Result<Vec<SystemBackupPolicyRunTargetClaim>, sqlx::Error> {
218 match kind {
219 ServerBackupKind::Server => {
220 let rows = sqlx::query!(
221 r#"
222 WITH in_flight AS (
223 SELECT server_backups.node_uuid AS scope_uuid, COUNT(*) AS count
224 FROM server_backups
225 WHERE
226 server_backups.system_backup_policy_uuid = $1
227 AND server_backups.completed IS NULL
228 AND server_backups.deleted IS NULL
229 AND server_backups.created >= NOW() - INTERVAL '1 day'
230 GROUP BY server_backups.node_uuid
231 ),
232 ranked AS (
233 SELECT
234 system_backup_policy_run_targets.uuid,
235 system_backup_policy_run_targets.server_uuid,
236 system_backup_policy_runs.created AS run_created,
237 servers.node_uuid AS scope_uuid,
238 ROW_NUMBER() OVER (
239 PARTITION BY servers.node_uuid
240 ORDER BY system_backup_policy_run_targets.last_attempt ASC NULLS FIRST, system_backup_policy_run_targets.uuid
241 ) AS position
242 FROM system_backup_policy_run_targets
243 JOIN system_backup_policy_runs ON system_backup_policy_runs.uuid = system_backup_policy_run_targets.system_backup_policy_run_uuid
244 LEFT JOIN servers ON servers.uuid = system_backup_policy_run_targets.server_uuid
245 WHERE
246 system_backup_policy_runs.system_backup_policy_uuid = $1
247 AND system_backup_policy_runs.completed IS NULL
248 AND system_backup_policy_run_targets.status = 'PENDING'
249 AND (
250 system_backup_policy_run_targets.not_before IS NULL
251 OR system_backup_policy_run_targets.not_before <= NOW()
252 )
253 )
254 SELECT
255 ranked.uuid AS "uuid!",
256 ranked.server_uuid AS "server_uuid?",
257 (
258 SELECT server_backups.uuid
259 FROM server_backups
260 WHERE
261 server_backups.system_backup_policy_uuid = $1
262 AND server_backups.server_uuid = ranked.server_uuid
263 AND server_backups.created >= ranked.run_created
264 ORDER BY server_backups.created DESC
265 LIMIT 1
266 ) AS "existing_server_backup_uuid?"
267 FROM ranked
268 LEFT JOIN in_flight ON in_flight.scope_uuid = ranked.scope_uuid
269 WHERE
270 ranked.scope_uuid IS NULL
271 OR ranked.position <= $2 - COALESCE(in_flight.count, 0)
272 ORDER BY ranked.position, ranked.uuid
273 LIMIT $3
274 "#,
275 system_backup_policy_uuid,
276 parallelism as i64,
277 limit,
278 )
279 .fetch_all(database.write())
280 .await?;
281
282 Ok(rows
283 .into_iter()
284 .map(|row| SystemBackupPolicyRunTargetClaim {
285 uuid: row.uuid,
286 server: row.server_uuid.map(super::server::Server::get_fetchable),
287 database_instance: None,
288 existing_server_backup: row
289 .existing_server_backup_uuid
290 .map(super::server_backup::ServerBackup::get_fetchable),
291 })
292 .collect())
293 }
294 ServerBackupKind::DatabaseInstance => {
295 let rows = sqlx::query!(
296 r#"
297 WITH in_flight AS (
298 SELECT server_database_instances.database_agent_host_uuid AS scope_uuid, COUNT(*) AS count
299 FROM server_backups
300 JOIN server_database_instances ON server_database_instances.uuid = server_backups.database_instance_uuid
301 WHERE
302 server_backups.system_backup_policy_uuid = $1
303 AND server_backups.completed IS NULL
304 AND server_backups.deleted IS NULL
305 AND server_backups.created >= NOW() - INTERVAL '1 day'
306 GROUP BY server_database_instances.database_agent_host_uuid
307 ),
308 ranked AS (
309 SELECT
310 system_backup_policy_run_targets.uuid,
311 system_backup_policy_run_targets.server_uuid,
312 system_backup_policy_run_targets.database_instance_uuid,
313 system_backup_policy_runs.created AS run_created,
314 server_database_instances.database_agent_host_uuid AS scope_uuid,
315 ROW_NUMBER() OVER (
316 PARTITION BY server_database_instances.database_agent_host_uuid
317 ORDER BY system_backup_policy_run_targets.last_attempt ASC NULLS FIRST, system_backup_policy_run_targets.uuid
318 ) AS position
319 FROM system_backup_policy_run_targets
320 JOIN system_backup_policy_runs ON system_backup_policy_runs.uuid = system_backup_policy_run_targets.system_backup_policy_run_uuid
321 LEFT JOIN server_database_instances ON server_database_instances.uuid = system_backup_policy_run_targets.database_instance_uuid
322 WHERE
323 system_backup_policy_runs.system_backup_policy_uuid = $1
324 AND system_backup_policy_runs.completed IS NULL
325 AND system_backup_policy_run_targets.status = 'PENDING'
326 AND (
327 system_backup_policy_run_targets.not_before IS NULL
328 OR system_backup_policy_run_targets.not_before <= NOW()
329 )
330 )
331 SELECT
332 ranked.uuid AS "uuid!",
333 ranked.server_uuid AS "server_uuid?",
334 ranked.database_instance_uuid AS "database_instance_uuid?",
335 (
336 SELECT server_backups.uuid
337 FROM server_backups
338 WHERE
339 server_backups.system_backup_policy_uuid = $1
340 AND server_backups.database_instance_uuid = ranked.database_instance_uuid
341 AND server_backups.created >= ranked.run_created
342 ORDER BY server_backups.created DESC
343 LIMIT 1
344 ) AS "existing_server_backup_uuid?"
345 FROM ranked
346 LEFT JOIN in_flight ON in_flight.scope_uuid = ranked.scope_uuid
347 WHERE
348 ranked.scope_uuid IS NULL
349 OR ranked.position <= $2 - COALESCE(in_flight.count, 0)
350 ORDER BY ranked.position, ranked.uuid
351 LIMIT $3
352 "#,
353 system_backup_policy_uuid,
354 parallelism as i64,
355 limit,
356 )
357 .fetch_all(database.write())
358 .await?;
359
360 Ok(rows
361 .into_iter()
362 .map(|row| SystemBackupPolicyRunTargetClaim {
363 uuid: row.uuid,
364 server: row.server_uuid.map(super::server::Server::get_fetchable),
365 database_instance: row.database_instance_uuid.map(
366 super::server_database_instance::ServerDatabaseInstance::get_fetchable,
367 ),
368 existing_server_backup: row
369 .existing_server_backup_uuid
370 .map(super::server_backup::ServerBackup::get_fetchable),
371 })
372 .collect())
373 }
374 }
375 }
376
377 pub async fn set_dispatched(
378 database: &crate::database::Database,
379 uuid: uuid::Uuid,
380 server_backup_uuid: uuid::Uuid,
381 ) -> Result<(), sqlx::Error> {
382 sqlx::query!(
383 "UPDATE system_backup_policy_run_targets
384 SET status = 'DISPATCHED', reason = NULL, server_backup_uuid = $2, not_before = NULL, updated = NOW()
385 WHERE system_backup_policy_run_targets.uuid = $1",
386 uuid,
387 server_backup_uuid,
388 )
389 .execute(database.write())
390 .await?;
391
392 Ok(())
393 }
394
395 pub async fn set_deferred(
396 database: &crate::database::Database,
397 uuid: uuid::Uuid,
398 reason: Option<SystemBackupPolicyRunTargetReason>,
399 not_before: chrono::NaiveDateTime,
400 ) -> Result<(), sqlx::Error> {
401 sqlx::query!(
402 "UPDATE system_backup_policy_run_targets
403 SET reason = COALESCE($2, system_backup_policy_run_targets.reason), not_before = $3, updated = NOW()
404 WHERE system_backup_policy_run_targets.uuid = $1 AND system_backup_policy_run_targets.status = 'PENDING'",
405 uuid,
406 reason as Option<SystemBackupPolicyRunTargetReason>,
407 not_before,
408 )
409 .execute(database.write())
410 .await?;
411
412 Ok(())
413 }
414
415 pub async fn set_resolved(
416 database: &crate::database::Database,
417 uuid: uuid::Uuid,
418 status: SystemBackupPolicyRunTargetStatus,
419 reason: SystemBackupPolicyRunTargetReason,
420 ) -> Result<(), sqlx::Error> {
421 sqlx::query!(
422 "UPDATE system_backup_policy_run_targets
423 SET status = $2, reason = $3, not_before = NULL, updated = NOW()
424 WHERE system_backup_policy_run_targets.uuid = $1 AND system_backup_policy_run_targets.status = 'PENDING'",
425 uuid,
426 status as SystemBackupPolicyRunTargetStatus,
427 reason as SystemBackupPolicyRunTargetReason,
428 )
429 .execute(database.write())
430 .await?;
431
432 Ok(())
433 }
434}
435
436#[async_trait::async_trait]
437impl IntoAdminApiObject for SystemBackupPolicyRunTarget {
438 type AdminApiObject = AdminApiSystemBackupPolicyRunTarget;
439 type ExtraArgs<'a> = &'a crate::storage::StorageUrlRetriever<'a>;
440
441 async fn into_admin_api_object<'a>(
442 self,
443 state: &crate::State,
444 storage_url_retriever: Self::ExtraArgs<'a>,
445 ) -> Result<Self::AdminApiObject, crate::database::DatabaseError> {
446 let api_object = AdminApiSystemBackupPolicyRunTarget::init_hooks(&self, state).await?;
447
448 let server = match self.server {
449 Some(server) => match server.fetch_optional_cached(&state.database).await? {
450 Some(server) => Some(
451 server
452 .into_admin_api_object(state, storage_url_retriever)
453 .await?,
454 ),
455 None => None,
456 },
457 None => None,
458 };
459
460 let api_object = finish_extendible!(
461 AdminApiSystemBackupPolicyRunTarget {
462 uuid: self.uuid,
463 server,
464 database_instance_uuid: self
465 .database_instance
466 .map(|database_instance| database_instance.uuid),
467 database_instance_name: self.database_instance_name,
468 server_backup_uuid: self.server_backup.map(|server_backup| server_backup.uuid),
469 server_backup_successful: self.server_backup_successful,
470 server_backup_completed: self.server_backup_completed.map(|dt| dt.and_utc()),
471 status: self.status,
472 reason: self.reason,
473 not_before: self.not_before.map(|dt| dt.and_utc()),
474 updated: self.updated.and_utc(),
475 },
476 api_object,
477 state
478 )?;
479
480 Ok(api_object)
481 }
482}
483
484#[schema_extension_derive::extendible]
485#[init_args(SystemBackupPolicyRunTarget, crate::State)]
486#[hook_args(crate::State)]
487#[derive(ToSchema, Serialize)]
488#[schema(title = "SystemBackupPolicyRunTarget")]
489pub struct AdminApiSystemBackupPolicyRunTarget {
490 pub uuid: uuid::Uuid,
491 pub server: Option<super::server::AdminApiServer>,
492 pub database_instance_uuid: Option<uuid::Uuid>,
493 pub database_instance_name: Option<compact_str::CompactString>,
494 pub server_backup_uuid: Option<uuid::Uuid>,
495 pub server_backup_successful: Option<bool>,
496 pub server_backup_completed: Option<chrono::DateTime<chrono::Utc>>,
497
498 pub status: SystemBackupPolicyRunTargetStatus,
499 pub reason: Option<SystemBackupPolicyRunTargetReason>,
500
501 pub not_before: Option<chrono::DateTime<chrono::Utc>>,
502 pub updated: chrono::DateTime<chrono::Utc>,
503}