Skip to main content

shared/models/
system_backup_policy_run_target.rs

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}