Struct ServerBackup 

pub struct ServerBackup {

    pub uuid: Uuid,
    pub server: Option<Fetchable<Server>>,
    pub node: Fetchable<Node>,
    pub backup_configuration: Option<Fetchable<BackupConfiguration>>,
    pub backup_group_uuid: Option<Uuid>,
    pub system_backup_policy_uuid: Option<Uuid>,
    pub database_instance_uuid: Option<Uuid>,
    pub kind: ServerBackupKind,
    pub database_type: Option<DatabaseAgentType>,
    pub name: CompactString,
    pub successful: bool,
    pub browsable: bool,
    pub streaming: bool,
    pub locked: bool,
    pub shared: bool,
    pub ignored_files: Vec<CompactString>,
    pub checksum: Option<CompactString>,
    pub bytes: i64,
    pub files: i64,
    pub disk: BackupDisk,
    pub upload_id: Option<CompactString>,
    pub upload_path: Option<CompactString>,
    pub metadata: Value,
    pub completed: Option<NaiveDateTime>,
    pub deleting: Option<NaiveDateTime>,
    pub deletion_retries: i32,
    pub deleted: Option<NaiveDateTime>,
    pub created: NaiveDateTime,
    /* private fields */
}

Fields

uuid: Uuid

server: Option<Fetchable<Server>>

node: Fetchable<Node>

backup_configuration: Option<Fetchable<BackupConfiguration>>

backup_group_uuid: Option<Uuid>

system_backup_policy_uuid: Option<Uuid>

database_instance_uuid: Option<Uuid>

kind: ServerBackupKind

database_type: Option<DatabaseAgentType>

name: CompactString

successful: bool

browsable: bool

streaming: bool

locked: bool

shared: bool

ignored_files: Vec<CompactString>

checksum: Option<CompactString>

bytes: i64

files: i64

disk: BackupDisk

upload_id: Option<CompactString>

upload_path: Option<CompactString>

metadata: Value

completed: Option<NaiveDateTime>

deleting: Option<NaiveDateTime>

deletion_retries: i32

deleted: Option<NaiveDateTime>

created: NaiveDateTime

Implementations

impl ServerBackup

pub async fn prune_retention_for_backup( state: &State, backup_uuid: Uuid, ) -> Result<u64, Error>

pub async fn prune_ungrouped_backups(state: &State) -> Result<u64, Error>

pub async fn evict_for_create( state: &State, server_uuid: Uuid, kind: ServerBackupKind, mode: EvictionMode, ) -> Result<u64, Error>

Frees a slot for a server that has reached its backup_limit by making room for a backup of kind, returning how many deletions were successfully dispatched. Node deletions complete asynchronously, so the caller must subtract this from its own count rather than counting again.

pub async fn prune_group_backups(state: &State) -> Result<u64, Error>

pub async fn prune_system_backups(state: &State) -> Result<u64, Error>

impl ServerBackup

pub async fn create_raw( state: &State, options: CreateServerBackupOptions<'_>, ) -> Result<Self, Error>

pub async fn by_server_uuid_uuid( database: &Database, server_uuid: Uuid, uuid: Uuid, ) -> Result<Option<Self>, DatabaseError>

pub async fn select_completed_by_server_uuid( database: &Database, server_uuid: Uuid, name: Option<&str>, backup_group_uuid: Option<Uuid>, filter: &ServerBackupFilter, oldest: bool, ) -> Result<Option<Self>, DatabaseError>

pub async fn by_node_uuid_uuid( database: &Database, node_uuid: Uuid, uuid: Uuid, ) -> Result<Option<Self>, DatabaseError>

pub async fn by_server_uuid_with_pagination( database: &Database, server_uuid: Uuid, page: i64, per_page: i64, search: Option<&str>, ) -> Result<Pagination<Self>, DatabaseError>

pub async fn by_server_uuid_node_uuid_with_pagination( database: &Database, server_uuid: Uuid, node_uuid: Uuid, page: i64, per_page: i64, search: Option<&str>, filter: &ServerBackupFilter, ) -> Result<Pagination<Self>, DatabaseError>

pub async fn by_server_uuid_node_uuid_backup_group_uuid_with_pagination( database: &Database, server_uuid: Uuid, node_uuid: Uuid, backup_group_uuid: Uuid, page: i64, per_page: i64, search: Option<&str>, ) -> Result<Pagination<Self>, DatabaseError>

pub async fn by_ungrouped_server_uuid_node_uuid_with_pagination( database: &Database, server_uuid: Uuid, node_uuid: Uuid, page: i64, per_page: i64, search: Option<&str>, filter: &ServerBackupFilter, ) -> Result<Pagination<Self>, DatabaseError>

pub async fn usage_by_server_uuid( database: &Database, server_uuid: Uuid, ) -> Result<ServerBackupUsage, Error>

pub async fn by_system_server_uuid_node_uuid_with_pagination( database: &Database, server_uuid: Uuid, node_uuid: Uuid, page: i64, per_page: i64, search: Option<&str>, ) -> Result<Pagination<Self>, DatabaseError>

pub async fn by_system_backup_policy_uuid_with_pagination( database: &Database, system_backup_policy_uuid: Uuid, page: i64, per_page: i64, search: Option<&str>, ) -> Result<Pagination<Self>, DatabaseError>

pub async fn all_by_system_backup_policy_uuid( database: &Database, system_backup_policy_uuid: Uuid, ) -> Result<Vec<Self>, DatabaseError>

pub async fn by_partially_detached_server_uuid_node_uuid_with_pagination( database: &Database, server_uuid: Uuid, node_uuid: Uuid, page: i64, per_page: i64, search: Option<&str>, ) -> Result<Pagination<Self>, DatabaseError>

pub async fn by_node_uuid_with_pagination( database: &Database, node_uuid: Uuid, page: i64, per_page: i64, search: Option<&str>, ) -> Result<Pagination<Self>, DatabaseError>

pub async fn by_database_agent_host_uuid_with_pagination( database: &Database, database_agent_host_uuid: Uuid, page: i64, per_page: i64, search: Option<&str>, ) -> Result<Pagination<Self>, DatabaseError>

pub async fn by_backup_configuration_uuid_with_pagination( database: &Database, backup_configuration_uuid: Uuid, page: i64, per_page: i64, search: Option<&str>, ) -> Result<Pagination<Self>, DatabaseError>

pub async fn by_detached_node_uuid_with_pagination( database: &Database, node_uuid: Uuid, page: i64, per_page: i64, search: Option<&str>, ) -> Result<Pagination<Self>, DatabaseError>

pub async fn all_uuids_by_server_uuid( database: &Database, server_uuid: Uuid, ) -> Result<Vec<Uuid>, DatabaseError>

pub async fn all_uuids_by_server_uuid_not_shared( database: &Database, server_uuid: Uuid, ) -> Result<Vec<Uuid>, DatabaseError>

pub async fn all_by_server_uuid( database: &Database, server_uuid: Uuid, ) -> Result<Vec<Self>, DatabaseError>

pub async fn count_by_server_uuid( database: &Database, server_uuid: Uuid, ) -> Result<i64, Error>

pub async fn count_system_inflight_by_system_backup_policy_uuid_node_uuid( database: &Database, system_backup_policy_uuid: Uuid, node_uuid: Uuid, ) -> Result<i64, Error>

In-flight system backups for a single policy on a node, ignoring rows older than a day (those are only failed-out when the wings node resets and must not starve the scheduler forever).

pub async fn count_system_inflight_by_system_backup_policy_uuid_database_agent_host_uuid( database: &Database, system_backup_policy_uuid: Uuid, database_agent_host_uuid: Uuid, ) -> Result<i64, Error>

Sibling of Self::count_system_inflight_by_system_backup_policy_uuid_node_uuid for database instance policies, whose dumps load the database agent host rather than the node.

pub async fn generate_metadata( state: &State, server: &Server, ) -> Result<Value, Error>

pub fn generate_database_metadata( database_instance: &ServerDatabaseInstance, ) -> Value

pub fn database_dump_name(&self) -> CompactString

The file name (without compression suffix) wings stores a database dump under.

pub async fn download_url( &self, state: &State, user: &User, node: &Node, archive_format: StreamableArchiveFormat, ) -> Result<String, Error>

pub async fn restore( self, state: &State, transaction: &mut Transaction<'_, Postgres>, server: Server, options: ServerBackupRestoreOptions, ) -> Result<(), Error>

pub async fn restore_database( self, state: &State, server: Server, database_instance: &ServerDatabaseInstance, request_uuid: Option<Uuid>, ) -> Result<(), Error>

pub async fn restore_startup( &self, state: &State, transaction: &mut Transaction<'_, Postgres>, server: &mut Server, ) -> Result<(), Error>

pub async fn wings_restore_download_url( &self, state: &State, server_uuid: Uuid, ) -> Result<Option<CompactString>, Error>

pub async fn export( &self, state: &State, server: &Server, path: CompactString, archive_format: StreamableArchiveFormat, foreground: bool, ) -> Result<Response, Error>

pub async fn query(&self, state: &State, node: &Node) -> Result<Response, Error>

pub fn default_name() -> CompactString

pub fn s3_path( &self, server_uuid: Uuid, compression_type: CompressionType, ) -> CompactString

pub fn s3_content_type(name: &str) -> &'static str

pub async fn into_admin_node_api_object( self, state: &State, storage_url_retriever: &StorageUrlRetriever<'_>, ) -> Result<AdminApiNodeServerBackup, DatabaseError>

impl ServerBackup

pub const MAX_DELETION_RETRIES: i32 = 8

pub fn deletion_status(&self) -> Option<ServerBackupDeletionStatus>

pub async fn dispatch_deletion( &self, state: &State, options: &DeleteServerBackupOptions, ) -> Result<bool, Error>

pub async fn finish_deletion( &self, state: &State, options: &DeleteServerBackupOptions, ) -> Result<(), Error>

pub async fn fail_deletion_attempt(&self, state: &State) -> Result<i32, Error>

pub async fn redispatch_stale_deletions(state: &State) -> Result<u64, Error>

impl ServerBackup

pub async fn count_failed( database: &Database, scope: FailedServerBackupScope, ) -> Result<i64, Error>

pub async fn delete_failed( state: &State, scope: FailedServerBackupScope, force: bool, ) -> Result<u64, Error>

Deletes every failed backup in scope, returning how many deletions were dispatched. Each chunk is claimed in its own transaction so the rows show as deleting straight away, and a panel restart mid-sweep leaves them to redispatch_stale_deletions.

Trait Implementations

impl BaseModel for ServerBackup

const NAME: &'static str = "server_backup"

fn get_extension_list() -> &'static ModelExtensionList

fn get_extension_data(&self) -> &ModelExtensionData

fn base_columns(prefix: Option<&str>) -> BTreeMap<&'static str, CompactString>

fn map(prefix: Option<&str>, row: &PgRow) -> Result<Self, DatabaseError>

fn register_model_extension( extension: impl ModelExtension + Send + Sync + 'static, )

Registers a model extension. If an extension with the same name is already registered, this function will do nothing.

fn parse_model_extension<Extension: SafeModelExtension>( &self, ) -> Result<Extension::Value, DatabaseError>

where Extension::Value: Serialize + DeserializeOwned,

Parses a model extension from the model’s extension data. If the extension is not found, or if the data cannot be deserialized, an error is returned.

fn columns(prefix: Option<&str>) -> BTreeMap<&'static str, CompactString>

fn columns_sql(prefix: Option<&str>) -> CompactString

fn map_extensions( prefix: &str, row: &PgRow, ) -> Result<ModelExtensionData, DatabaseError>

fn cache_invalidation_keys(&self) -> Vec<CompactString>

impl ByUuid for ServerBackup

fn by_uuid<'life0, 'async_trait>( database: &'life0 Database, uuid: Uuid, ) -> Pin<Box<dyn Future<Output = Result<Self, DatabaseError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn by_uuid_with_transaction<'life0, 'life1, 'async_trait>( transaction: &'life0 mut Transaction<'life1, Postgres>, uuid: Uuid, ) -> Pin<Box<dyn Future<Output = Result<Self, DatabaseError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn by_uuid_cached<'life0, 'async_trait>( database: &'life0 Database, uuid: Uuid, ) -> Pin<Box<dyn Future<Output = Result<Self, Error>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait,

fn by_uuid_optional<'life0, 'async_trait>( database: &'life0 Database, uuid: Uuid, ) -> Pin<Box<dyn Future<Output = Result<Option<Self>, DatabaseError>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait,

fn by_uuid_optional_with_transaction<'life0, 'life1, 'async_trait>( transaction: &'life0 mut Transaction<'life1, Postgres>, uuid: Uuid, ) -> Pin<Box<dyn Future<Output = Result<Option<Self>, DatabaseError>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn by_uuid_optional_cached<'life0, 'async_trait>( database: &'life0 Database, uuid: Uuid, ) -> Pin<Box<dyn Future<Output = Result<Option<Self>, Error>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait,

fn get_fetchable(uuid: Uuid) -> Fetchable<Self>

fn get_fetchable_from_row( row: &PgRow, column: impl AsRef<str>, ) -> Option<Fetchable<Self>>

fn invalidate_cached<'life0, 'async_trait>( database: &'life0 Database, uuid: Uuid, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait,

impl Clone for ServerBackup

fn clone(&self) -> ServerBackup

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl CreatableModel for ServerBackup

type CreateOptions<'a> = CreateServerBackupOptions<'a>

type CreateResult = ServerBackup

fn get_create_handlers() -> &'static LazyLock<CreateListenerList<Self>>

fn create_with_transaction<'life0, 'life1, 'life2, 'life3, 'async_trait>( _state: &'life0 State, _options: Self::CreateOptions<'life1>, _transaction: &'life2 mut Transaction<'life3, Postgres>, ) -> Pin<Box<dyn Future<Output = Result<Self, DatabaseError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

fn create<'life0, 'life1, 'async_trait>( state: &'life0 State, options: Self::CreateOptions<'life1>, ) -> Pin<Box<dyn Future<Output = Result<Self, DatabaseError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn register_create_handler<F: for<'a> Fn(&'a mut Self::CreateOptions<'_>, &'a mut InsertQueryBuilder<'_>, &'a State, &'a mut Transaction<'_, Postgres>) -> Pin<Box<dyn Future<Output = Result<(), DatabaseError>> + Send + 'a>> + Send + Sync + 'static>( priority: ListenerPriority, callback: F, )

fn register_after_create_handler<F: for<'a> Fn(&'a mut Self::CreateResult, &'a Self::CreateOptions<'_>, &'a State, &'a mut Transaction<'_, Postgres>) -> Pin<Box<dyn Future<Output = Result<(), DatabaseError>> + Send + 'a>> + Send + Sync + 'static>( priority: ListenerPriority, callback: F, )

fn run_create_handlers<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>( options: &'life0 mut Self::CreateOptions<'life1>, query_builder: &'life2 mut InsertQueryBuilder<'_>, state: &'life3 State, transaction: &'life4 mut Transaction<'life5, Postgres>, ) -> Pin<Box<dyn Future<Output = Result<(), DatabaseError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, 'life5: 'async_trait,

fn run_after_create_handlers<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>( result: &'life0 mut Self::CreateResult, options: &'life1 Self::CreateOptions<'life2>, state: &'life3 State, transaction: &'life4 mut Transaction<'life5, Postgres>, ) -> Pin<Box<dyn Future<Output = Result<(), DatabaseError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, 'life5: 'async_trait,

impl DeletableModel for ServerBackup

type DeleteOptions = DeleteServerBackupOptions

fn get_delete_handlers() -> &'static LazyLock<DeleteHandlerList<Self>>

fn delete_with_transaction<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _state: &'life1 State, _options: Self::DeleteOptions, _transaction: &'life2 mut Transaction<'life3, Postgres>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

fn delete<'life0, 'life1, 'async_trait>( &'life0 self, state: &'life1 State, options: Self::DeleteOptions, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn register_delete_handler<F: for<'a> Fn(&'a Self, &'a Self::DeleteOptions, &'a State, &'a mut Transaction<'_, Postgres>) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>> + Send + Sync + 'static>( priority: ListenerPriority, callback: F, )

fn register_after_delete_handler<F: for<'a> Fn(&'a Self, &'a Self::DeleteOptions, &'a State, &'a mut Transaction<'_, Postgres>) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>> + Send + Sync + 'static>( priority: ListenerPriority, callback: F, )

fn run_delete_handlers<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, options: &'life1 Self::DeleteOptions, state: &'life2 State, transaction: &'life3 mut Transaction<'life4, Postgres>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

fn run_after_delete_handlers<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, options: &'life1 Self::DeleteOptions, state: &'life2 State, transaction: &'life3 mut Transaction<'life4, Postgres>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

impl<'de> Deserialize<'de> for ServerBackup

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl EventEmittingModel for ServerBackup

type Event = ServerBackupEvent

fn get_event_emitter() -> &'static EventEmitter<Self::Event>

fn register_event_handler<F: Fn(State, Arc<Self::Event>) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<(), Error>> + Send + 'static>( listener: F, ) -> EventHandlerHandle

impl IntoAdminApiObject for ServerBackup

type AdminApiObject = AdminApiServerBackup

type ExtraArgs<'a> = &'a StorageUrlRetriever<'a>

fn into_admin_api_object<'a, 'life0, 'async_trait>( self, state: &'life0 State, storage_url_retriever: Self::ExtraArgs<'a>, ) -> Pin<Box<dyn Future<Output = Result<Self::AdminApiObject, DatabaseError>> + Send + 'async_trait>>

where Self: 'async_trait, 'a: 'async_trait, 'life0: 'async_trait,

impl IntoApiObject for ServerBackup

type ApiObject = ApiServerBackup

type ExtraArgs<'a> = ()

fn into_api_object<'a, 'life0, 'async_trait>( self, state: &'life0 State, _args: Self::ExtraArgs<'a>, ) -> Pin<Box<dyn Future<Output = Result<Self::ApiObject, DatabaseError>> + Send + 'async_trait>>

where Self: 'async_trait, 'a: 'async_trait, 'life0: 'async_trait,

impl Serialize for ServerBackup

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl UpdatableModel for ServerBackup

type UpdateOptions = UpdateServerBackupOptions

fn get_update_handlers() -> &'static LazyLock<UpdateHandlerList<Self>>

fn update_with_transaction<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 mut self, state: &'life1 State, options: Self::UpdateOptions, transaction: &'life2 mut Transaction<'life3, Postgres>, ) -> Pin<Box<dyn Future<Output = Result<(), DatabaseError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

fn register_update_handler<F: for<'a> Fn(&'a mut Self, &'a mut Self::UpdateOptions, &'a mut UpdateQueryBuilder<'_>, &'a State, &'a mut Transaction<'_, Postgres>) -> Pin<Box<dyn Future<Output = Result<(), DatabaseError>> + Send + 'a>> + Send + Sync + 'static>( priority: ListenerPriority, callback: F, )

fn register_after_update_handler<F: for<'a> Fn(&'a mut Self, &'a State, &'a mut Transaction<'_, Postgres>) -> Pin<Box<dyn Future<Output = Result<(), DatabaseError>> + Send + 'a>> + Send + Sync + 'static>( priority: ListenerPriority, callback: F, )

fn run_update_handlers<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>( &'life0 mut self, options: &'life1 mut Self::UpdateOptions, query_builder: &'life2 mut UpdateQueryBuilder<'_>, state: &'life3 State, transaction: &'life4 mut Transaction<'life5, Postgres>, ) -> Pin<Box<dyn Future<Output = Result<(), DatabaseError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, 'life5: 'async_trait,

fn run_after_update_handlers<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 mut self, state: &'life1 State, transaction: &'life2 mut Transaction<'life3, Postgres>, ) -> Pin<Box<dyn Future<Output = Result<(), DatabaseError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

fn update<'life0, 'life1, 'async_trait>( &'life0 mut self, state: &'life1 State, options: Self::UpdateOptions, ) -> Pin<Box<dyn Future<Output = Result<(), DatabaseError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,