kcr_dataprotection_kubeblocks_io 3.20260114.105424

// WARNING: generated by kopium - manual changes will be overwritten
// kopium command: kopium --docs --derive=Default --derive=PartialEq --smart-derive-elision --filename crd-catalog/apecloud/kubeblocks/dataprotection.kubeblocks.io/v1alpha1/backuppolicytemplates.yaml
// kopium version: 0.22.5

#[allow(unused_imports)]
mod prelude {
    pub use kube::CustomResource;
    pub use serde::{Serialize, Deserialize};
    pub use std::collections::BTreeMap;
    pub use k8s_openapi::apimachinery::pkg::util::intstr::IntOrString;
}
use self::prelude::*;

/// Defines the desired state of the BackupPolicyTemplate.
#[derive(CustomResource, Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
#[kube(group = "dataprotection.kubeblocks.io", version = "v1alpha1", kind = "BackupPolicyTemplate", plural = "backuppolicytemplates")]
#[kube(status = "BackupPolicyTemplateStatus")]
#[kube(schema = "disabled")]
#[kube(derive="Default")]
#[kube(derive="PartialEq")]
pub struct BackupPolicyTemplateSpec {
    /// Specifies the maximum number of retry attempts for a backup before it is considered a failure.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "backoffLimit")]
    pub backoff_limit: Option<i32>,
    /// Defines an array of BackupMethods to be used.
    #[serde(rename = "backupMethods")]
    pub backup_methods: Vec<BackupPolicyTemplateBackupMethods>,
    /// CompDefs specifies names for the component definitions associated with this BackupPolicyTemplate.
    /// Each name in the list can represent an exact name, a name prefix, or a regular expression pattern.
    /// 
    /// 
    /// For example:
    /// 
    /// 
    /// - "mysql-8.0.30-v1alpha1": Matches the exact name "mysql-8.0.30-v1alpha1"
    /// - "mysql-8.0.30": Matches all names starting with "mysql-8.0.30"
    /// - "^mysql-8.0.\d{1,2}$": Matches all names starting with "mysql-8.0." followed by one or two digits.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "compDefs")]
    pub comp_defs: Option<Vec<String>>,
    /// Defines the backup retention policy to be used.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "retentionPolicy")]
    pub retention_policy: Option<BackupPolicyTemplateRetentionPolicy>,
    /// Defines the execution plans for backup tasks, specifying when and how backups should occur,
    /// and the retention period of backup files.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub schedules: Option<Vec<BackupPolicyTemplateSchedules>>,
    /// Defines the type of well-known service protocol that the BackupPolicyTemplate provides, and it is optional.
    /// Some examples of well-known service protocols include:
    /// 
    /// 
    /// - "MySQL": Indicates that the Component provides a MySQL database service.
    /// - "PostgreSQL": Indicates that the Component offers a PostgreSQL database service.
    /// - "Redis": Signifies that the Component functions as a Redis key-value store.
    /// - "ETCD": Denotes that the Component serves as an ETCD distributed key-value store
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "serviceKind")]
    pub service_kind: Option<String>,
    /// Defines the selection criteria of instance to be backed up, and the connection credential to be used
    /// during the backup process.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub target: Option<BackupPolicyTemplateTarget>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct BackupPolicyTemplateBackupMethods {
    /// Refers to the ActionSet object that defines the backup actions.
    /// For volume snapshot backup, the actionSet is not required, the controller
    /// will use the CSI volume snapshotter to create the snapshot.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "actionSetName")]
    pub action_set_name: Option<String>,
    /// The name of the compatible full backup method, used by incremental backups.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "compatibleMethod")]
    pub compatible_method: Option<String>,
    /// Specifies the environment variables for the backup workload.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub env: Option<Vec<BackupPolicyTemplateBackupMethodsEnv>>,
    /// The name of backup method.
    pub name: String,
    /// Specifies runtime settings for the backup workload container.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "runtimeSettings")]
    pub runtime_settings: Option<BackupPolicyTemplateBackupMethodsRuntimeSettings>,
    /// Specifies whether to take snapshots of persistent volumes. If true,
    /// the ActionSetName is not required, the controller will use the CSI volume
    /// snapshotter to create the snapshot.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "snapshotVolumes")]
    pub snapshot_volumes: Option<bool>,
    /// If set, specifies the method for selecting the replica to be backed up using the criteria defined here.
    /// If this field is not set, the selection method specified in `backupPolicy.target` is used.
    /// 
    /// 
    /// This field provides a way to override the global `backupPolicy.target` setting for specific BackupMethod.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub target: Option<BackupPolicyTemplateBackupMethodsTarget>,
    /// Specifies which volumes from the target should be mounted in the backup workload.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "targetVolumes")]
    pub target_volumes: Option<BackupPolicyTemplateBackupMethodsTargetVolumes>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct BackupPolicyTemplateBackupMethodsEnv {
    /// Specifies the environment variable key.
    pub name: String,
    /// Specifies the environment variable value.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub value: Option<String>,
    /// Specifies the source used to determine the value of the environment variable.
    /// Cannot be used if value is not empty.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "valueFrom")]
    pub value_from: Option<BackupPolicyTemplateBackupMethodsEnvValueFrom>,
}

/// Specifies the source used to determine the value of the environment variable.
/// Cannot be used if value is not empty.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct BackupPolicyTemplateBackupMethodsEnvValueFrom {
    /// Determine the appropriate version of the backup tool image from service version.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "versionMapping")]
    pub version_mapping: Option<Vec<BackupPolicyTemplateBackupMethodsEnvValueFromVersionMapping>>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct BackupPolicyTemplateBackupMethodsEnvValueFromVersionMapping {
    /// Specifies a mapping value based on service version.
    /// Typically used to set up the tools image required for backup operations.
    #[serde(rename = "mappedValue")]
    pub mapped_value: String,
    /// Represents an array of the service version that can be mapped to the appropriate value.
    /// Each name in the list can represent an exact name, a name prefix, or a regular expression pattern.
    /// 
    /// 
    /// For example:
    /// 
    /// 
    /// - "8.0.33": Matches the exact name "8.0.33"
    /// - "8.0": Matches all names starting with "8.0"
    /// - "^8.0.\d{1,2}$": Matches all names starting with "8.0." followed by one or two digits.
    #[serde(rename = "serviceVersions")]
    pub service_versions: Vec<String>,
}

/// Specifies runtime settings for the backup workload container.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct BackupPolicyTemplateBackupMethodsRuntimeSettings {
    /// Specifies the resource required by container.
    /// More info: <https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/>
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resources: Option<BackupPolicyTemplateBackupMethodsRuntimeSettingsResources>,
}

/// Specifies the resource required by container.
/// More info: <https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/>
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct BackupPolicyTemplateBackupMethodsRuntimeSettingsResources {
    /// Claims lists the names of resources, defined in spec.resourceClaims,
    /// that are used by this container.
    /// 
    /// 
    /// This is an alpha field and requires enabling the
    /// DynamicResourceAllocation feature gate.
    /// 
    /// 
    /// This field is immutable. It can only be set for containers.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub claims: Option<Vec<BackupPolicyTemplateBackupMethodsRuntimeSettingsResourcesClaims>>,
    /// Limits describes the maximum amount of compute resources allowed.
    /// More info: <https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/>
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limits: Option<BTreeMap<String, IntOrString>>,
    /// Requests describes the minimum amount of compute resources required.
    /// If Requests is omitted for a container, it defaults to Limits if that is explicitly specified,
    /// otherwise to an implementation-defined value. Requests cannot exceed Limits.
    /// More info: <https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/>
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub requests: Option<BTreeMap<String, IntOrString>>,
}

/// ResourceClaim references one entry in PodSpec.ResourceClaims.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct BackupPolicyTemplateBackupMethodsRuntimeSettingsResourcesClaims {
    /// Name must match the name of one entry in pod.spec.resourceClaims of
    /// the Pod where this field is used. It makes that resource available
    /// inside a container.
    pub name: String,
}

/// If set, specifies the method for selecting the replica to be backed up using the criteria defined here.
/// If this field is not set, the selection method specified in `backupPolicy.target` is used.
/// 
/// 
/// This field provides a way to override the global `backupPolicy.target` setting for specific BackupMethod.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct BackupPolicyTemplateBackupMethodsTarget {
    /// If `backupPolicy.componentDefs` is set, this field is required to specify the system account name.
    /// This account must match one listed in `componentDefinition.spec.systemAccounts[*].name`.
    /// The corresponding secret created by this account is used to connect to the database.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
    /// Specifies the container port in the target pod.
    /// If not specified, the first container and its first port will be used.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "containerPort")]
    pub container_port: Option<BackupPolicyTemplateBackupMethodsTargetContainerPort>,
    /// Specifies the fallback role to select one replica for backup, this only takes effect when the
    /// `strategy` field below is set to `Any`.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fallbackRole")]
    pub fallback_role: Option<String>,
    /// Specifies the role to select one or more replicas for backup.
    /// 
    /// 
    /// - If no replica with the specified role exists, the backup task will fail.
    ///   Special case: If there is only one replica in the cluster, it will be used for backup,
    ///   even if its role differs from the specified one.
    ///   For example, if you specify backing up on a secondary replica, but the cluster is single-node
    ///   with only one primary replica, the primary will be used for backup.
    ///   Future versions will address this special case using role priorities.
    /// - If multiple replicas satisfy the specified role, the choice (`Any` or `All`) will be made according to
    ///   the `strategy` field below.
    pub role: String,
    /// Specifies the PodSelectionStrategy to use when multiple pods are
    /// selected for the backup target.
    /// Valid values are:
    /// 
    /// 
    /// - Any: Selects any one pod that matches the labelsSelector.
    /// - All: Selects all pods that match the labelsSelector.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub strategy: Option<BackupPolicyTemplateBackupMethodsTargetStrategy>,
    /// UseParentSelectedPods indicates whether to use the pods selected by the parent for backup.
    /// If set to true, the backup will use the same pods selected by the parent.
    /// And only takes effect when the 'strategy' is set to 'Any'.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "useParentSelectedPods")]
    pub use_parent_selected_pods: Option<bool>,
}

/// Specifies the container port in the target pod.
/// If not specified, the first container and its first port will be used.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct BackupPolicyTemplateBackupMethodsTargetContainerPort {
    /// Specifies the name of container with the port.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "containerName")]
    pub container_name: Option<String>,
    /// Specifies the port name.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "portName")]
    pub port_name: Option<String>,
}

/// If set, specifies the method for selecting the replica to be backed up using the criteria defined here.
/// If this field is not set, the selection method specified in `backupPolicy.target` is used.
/// 
/// 
/// This field provides a way to override the global `backupPolicy.target` setting for specific BackupMethod.
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum BackupPolicyTemplateBackupMethodsTargetStrategy {
    Any,
    All,
}

/// Specifies which volumes from the target should be mounted in the backup workload.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct BackupPolicyTemplateBackupMethodsTargetVolumes {
    /// Specifies the mount for the volumes specified in `volumes` section.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeMounts")]
    pub volume_mounts: Option<Vec<BackupPolicyTemplateBackupMethodsTargetVolumesVolumeMounts>>,
    /// Specifies the list of volumes of targeted application that should be mounted
    /// on the backup workload.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub volumes: Option<Vec<String>>,
}

/// VolumeMount describes a mounting of a Volume within a container.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct BackupPolicyTemplateBackupMethodsTargetVolumesVolumeMounts {
    /// Path within the container at which the volume should be mounted.  Must
    /// not contain ':'.
    #[serde(rename = "mountPath")]
    pub mount_path: String,
    /// mountPropagation determines how mounts are propagated from the host
    /// to container and the other way around.
    /// When not set, MountPropagationNone is used.
    /// This field is beta in 1.10.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "mountPropagation")]
    pub mount_propagation: Option<String>,
    /// This must match the Name of a Volume.
    pub name: String,
    /// Mounted read-only if true, read-write otherwise (false or unspecified).
    /// Defaults to false.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
    pub read_only: Option<bool>,
    /// Path within the volume from which the container's volume should be mounted.
    /// Defaults to "" (volume's root).
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "subPath")]
    pub sub_path: Option<String>,
    /// Expanded path within the volume from which the container's volume should be mounted.
    /// Behaves similarly to SubPath but environment variable references $(VAR_NAME) are expanded using the container's environment.
    /// Defaults to "" (volume's root).
    /// SubPathExpr and SubPath are mutually exclusive.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "subPathExpr")]
    pub sub_path_expr: Option<String>,
}

/// Defines the desired state of the BackupPolicyTemplate.
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum BackupPolicyTemplateRetentionPolicy {
    #[serde(rename = "retainLatestBackup")]
    RetainLatestBackup,
    #[serde(rename = "none")]
    None,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct BackupPolicyTemplateSchedules {
    /// Specifies the backup method name that is defined in backupPolicy.
    #[serde(rename = "backupMethod")]
    pub backup_method: String,
    /// Specifies the cron expression for the schedule. The timezone is in UTC.
    /// see <https://en.wikipedia.org/wiki/Cron.>
    #[serde(rename = "cronExpression")]
    pub cron_expression: String,
    /// Specifies whether the backup schedule is enabled or not.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
    /// Specifies the name of the schedule. Names cannot be duplicated.
    /// If the name is empty, it will be considered the same as the value of the backupMethod below.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Specifies a list of name-value pairs representing parameters and their corresponding values.
    /// Parameters match the schema specified in the `actionset.spec.parametersSchema`
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub parameters: Option<Vec<BackupPolicyTemplateSchedulesParameters>>,
    /// Determines the duration for which the backup should be kept.
    /// KubeBlocks will remove all backups that are older than the RetentionPeriod.
    /// For example, RetentionPeriod of `30d` will keep only the backups of last 30 days.
    /// Sample duration format:
    /// 
    /// 
    /// - years: 	2y
    /// - months: 	6mo
    /// - days: 		30d
    /// - hours: 	12h
    /// - minutes: 	30m
    /// 
    /// 
    /// You can also combine the above durations. For example: 30d12h30m
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "retentionPeriod")]
    pub retention_period: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct BackupPolicyTemplateSchedulesParameters {
    /// Represents the name of the parameter.
    pub name: String,
    /// Represents the parameter values.
    pub value: String,
}

/// Defines the selection criteria of instance to be backed up, and the connection credential to be used
/// during the backup process.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct BackupPolicyTemplateTarget {
    /// If `backupPolicy.componentDefs` is set, this field is required to specify the system account name.
    /// This account must match one listed in `componentDefinition.spec.systemAccounts[*].name`.
    /// The corresponding secret created by this account is used to connect to the database.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
    /// Specifies the container port in the target pod.
    /// If not specified, the first container and its first port will be used.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "containerPort")]
    pub container_port: Option<BackupPolicyTemplateTargetContainerPort>,
    /// Specifies the fallback role to select one replica for backup, this only takes effect when the
    /// `strategy` field below is set to `Any`.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fallbackRole")]
    pub fallback_role: Option<String>,
    /// Specifies the role to select one or more replicas for backup.
    /// 
    /// 
    /// - If no replica with the specified role exists, the backup task will fail.
    ///   Special case: If there is only one replica in the cluster, it will be used for backup,
    ///   even if its role differs from the specified one.
    ///   For example, if you specify backing up on a secondary replica, but the cluster is single-node
    ///   with only one primary replica, the primary will be used for backup.
    ///   Future versions will address this special case using role priorities.
    /// - If multiple replicas satisfy the specified role, the choice (`Any` or `All`) will be made according to
    ///   the `strategy` field below.
    pub role: String,
    /// Specifies the PodSelectionStrategy to use when multiple pods are
    /// selected for the backup target.
    /// Valid values are:
    /// 
    /// 
    /// - Any: Selects any one pod that matches the labelsSelector.
    /// - All: Selects all pods that match the labelsSelector.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub strategy: Option<BackupPolicyTemplateTargetStrategy>,
    /// UseParentSelectedPods indicates whether to use the pods selected by the parent for backup.
    /// If set to true, the backup will use the same pods selected by the parent.
    /// And only takes effect when the 'strategy' is set to 'Any'.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "useParentSelectedPods")]
    pub use_parent_selected_pods: Option<bool>,
}

/// Specifies the container port in the target pod.
/// If not specified, the first container and its first port will be used.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct BackupPolicyTemplateTargetContainerPort {
    /// Specifies the name of container with the port.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "containerName")]
    pub container_name: Option<String>,
    /// Specifies the port name.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "portName")]
    pub port_name: Option<String>,
}

/// Defines the selection criteria of instance to be backed up, and the connection credential to be used
/// during the backup process.
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum BackupPolicyTemplateTargetStrategy {
    Any,
    All,
}

/// Populated by the system, it represents the current information about the BackupPolicyTemplate.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct BackupPolicyTemplateStatus {
    /// Provides additional information about the current phase.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
    /// Represents the most recent generation observed for this BackupPolicyTemplate.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "observedGeneration")]
    pub observed_generation: Option<i64>,
    /// Specifies the current phase of the BackupPolicyTemplate. Valid values are `empty`, `Available`, `Unavailable`.
    /// When `Available`, the BackupPolicyTemplate is ready and can be referenced by related objects.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub phase: Option<BackupPolicyTemplateStatusPhase>,
}

/// Populated by the system, it represents the current information about the BackupPolicyTemplate.
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum BackupPolicyTemplateStatusPhase {
    Available,
    Unavailable,
}