data.proto

// Copyright 2023 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

syntax = "proto3";

package google.events.cloud.gkebackup.v1;

import "google/protobuf/timestamp.proto";

option csharp_namespace = "Google.Events.Protobuf.Cloud.GkeBackup.V1";
option php_namespace = "Google\\Events\\Cloud\\GkeBackup\\V1";
option ruby_package = "Google::Events::Cloud::GkeBackup::V1";

// A list of Kubernetes Namespaces
message Namespaces {
  // A list of Kubernetes Namespaces
  repeated string namespaces = 1;
}

// A reference to a namespaced resource in Kubernetes.
message NamespacedName {
  // The Namespace of the Kubernetes resource.
  string namespace = 1;

  // The name of the Kubernetes resource.
  string name = 2;
}

// A list of namespaced Kubernetes resources.
message NamespacedNames {
  // A list of namespaced Kubernetes resources.
  repeated NamespacedName namespaced_names = 1;
}

// Defined a customer managed encryption key that will be used to encrypt Backup
// artifacts.
message EncryptionKey {
  // Google Cloud KMS encryption key. Format:
  // `projects/*/locations/*/keyRings/*/cryptoKeys/*`
  string gcp_kms_encryption_key = 1;
}

// Represents a request to perform a single point-in-time capture of
// some portion of the state of a GKE cluster, the record of the backup
// operation itself, and an anchor for the underlying artifacts that
// comprise the Backup (the config backup and VolumeBackups).
// Next id: 28
message Backup {
  // Information about the GKE cluster from which this Backup was created.
  message ClusterMetadata {
    // The source cluster from which this Backup was created.
    // Valid formats:
    //
    //   - `projects/*/locations/*/clusters/*`
    //   - `projects/*/zones/*/clusters/*`
    //
    // This is inherited from the parent BackupPlan's
    // [cluster][google.cloud.gkebackup.v1.BackupPlan.cluster] field.
    string cluster = 1;

    // The Kubernetes server version of the source cluster.
    string k8s_version = 2;

    // A list of the Backup for GKE CRD versions found in the cluster.
    map<string, string> backup_crd_versions = 3;

    // Platform-specific version
    oneof platform_version {
      // GKE version
      string gke_version = 4;

      // Anthos version
      string anthos_version = 5;
    }
  }

  // State
  enum State {
    // The Backup resource is in the process of being created.
    STATE_UNSPECIFIED = 0;

    // The Backup resource has been created and the associated BackupJob
    // Kubernetes resource has been injected into the source cluster.
    CREATING = 1;

    // The gkebackup agent in the cluster has begun executing the backup
    // operation.
    IN_PROGRESS = 2;

    // The backup operation has completed successfully.
    SUCCEEDED = 3;

    // The backup operation has failed.
    FAILED = 4;

    // This Backup resource (and its associated artifacts) is in the process
    // of being deleted.
    DELETING = 5;
  }

  // Output only. The fully qualified name of the Backup.
  // `projects/*/locations/*/backupPlans/*/backups/*`
  string name = 1;

  // Output only. Server generated global unique identifier of
  // [UUID4](https://en.wikipedia.org/wiki/Universally_unique_identifier)
  string uid = 2;

  // Output only. The timestamp when this Backup resource was created.
  google.protobuf.Timestamp create_time = 3;

  // Output only. The timestamp when this Backup resource was last updated.
  google.protobuf.Timestamp update_time = 4;

  // Output only. This flag indicates whether this Backup resource was created
  // manually by a user or via a schedule in the BackupPlan. A value of True
  // means that the Backup was created manually.
  bool manual = 5;

  // A set of custom labels supplied by user.
  map<string, string> labels = 6;

  // Minimum age for this Backup (in days). If this field is set to a non-zero
  // value, the Backup will be "locked" against deletion (either manual or
  // automatic deletion) for the number of days provided (measured from the
  // creation time of the Backup).  MUST be an integer value between 0-90
  // (inclusive).
  //
  // Defaults to parent BackupPlan's
  // [backup_delete_lock_days][google.cloud.gkebackup.v1.BackupPlan.RetentionPolicy.backup_delete_lock_days]
  // setting and may only be increased
  // (either at creation time or in a subsequent update).
  int32 delete_lock_days = 7;

  // Output only. The time at which an existing delete lock will expire for this
  // backup (calculated from create_time +
  // [delete_lock_days][google.cloud.gkebackup.v1.Backup.delete_lock_days]).
  google.protobuf.Timestamp delete_lock_expire_time = 8;

  // The age (in days) after which this Backup will be automatically deleted.
  // Must be an integer value >= 0:
  //
  // - If 0, no automatic deletion will occur for this Backup.
  // - If not 0, this must be >=
  // [delete_lock_days][google.cloud.gkebackup.v1.Backup.delete_lock_days] and
  // <= 365.
  //
  // Once a Backup is created, this value may only be increased.
  //
  // Defaults to the parent BackupPlan's
  // [backup_retain_days][google.cloud.gkebackup.v1.BackupPlan.RetentionPolicy.backup_retain_days]
  // value.
  int32 retain_days = 9;

  // Output only. The time at which this Backup will be automatically deleted
  // (calculated from create_time +
  // [retain_days][google.cloud.gkebackup.v1.Backup.retain_days]).
  google.protobuf.Timestamp retain_expire_time = 10;

  // Output only. The customer managed encryption key that was used to encrypt
  // the Backup's artifacts.  Inherited from the parent BackupPlan's
  // [encryption_key][google.cloud.gkebackup.v1.BackupPlan.BackupConfig.encryption_key]
  // value.
  EncryptionKey encryption_key = 11;

  // Defines the "scope" of the Backup - which namespaced resources in the
  // cluster were included in the Backup.  Inherited from the parent
  // BackupPlan's
  // [backup_scope][google.cloud.gkebackup.v1.BackupPlan.BackupConfig.backup_scope]
  // value.
  oneof backup_scope {
    // Output only. If True, all namespaces were included in the Backup.
    bool all_namespaces = 12;

    // Output only. If set, the list of namespaces that were included in the
    // Backup.
    Namespaces selected_namespaces = 13;

    // Output only. If set, the list of ProtectedApplications whose resources
    // were included in the Backup.
    NamespacedNames selected_applications = 14;
  }

  // Output only. Whether or not the Backup contains volume data.  Controlled by
  // the parent BackupPlan's
  // [include_volume_data][google.cloud.gkebackup.v1.BackupPlan.BackupConfig.include_volume_data]
  // value.
  bool contains_volume_data = 15;

  // Output only. Whether or not the Backup contains Kubernetes Secrets.
  // Controlled by the parent BackupPlan's
  // [include_secrets][google.cloud.gkebackup.v1.BackupPlan.BackupConfig.include_secrets]
  // value.
  bool contains_secrets = 16;

  // Output only. Information about the GKE cluster from which this Backup was
  // created.
  ClusterMetadata cluster_metadata = 17;

  // Output only. Current state of the Backup
  State state = 18;

  // Output only. Human-readable description of why the backup is in the current
  // `state`.
  string state_reason = 19;

  // Output only. Completion time of the Backup
  google.protobuf.Timestamp complete_time = 20;

  // Output only. The total number of Kubernetes resources included in the
  // Backup.
  int32 resource_count = 21;

  // Output only. The total number of volume backups contained in the Backup.
  int32 volume_count = 22;

  // Output only. The total size of the Backup in bytes = config backup size +
  // sum(volume backup sizes)
  int64 size_bytes = 23;

  // Output only. `etag` is used for optimistic concurrency control as a way to
  // help prevent simultaneous updates of a backup from overwriting each other.
  // It is strongly suggested that systems make use of the `etag` in the
  // read-modify-write cycle to perform backup updates in order to avoid
  // race conditions: An `etag` is returned in the response to `GetBackup`,
  // and systems are expected to put that etag in the request to
  // `UpdateBackup` or `DeleteBackup` to ensure that their change will be
  // applied to the same version of the resource.
  string etag = 24;

  // User specified descriptive string for this Backup.
  string description = 25;

  // Output only. The total number of Kubernetes Pods contained in the Backup.
  int32 pod_count = 26;

  // Output only. The size of the config backup in bytes.
  int64 config_backup_size_bytes = 27;
}

// Defines the configuration and scheduling for a "line" of Backups.
message BackupPlan {
  // RetentionPolicy defines a Backup retention policy for a BackupPlan.
  message RetentionPolicy {
    // Minimum age for Backups created via this BackupPlan (in days).
    // This field MUST be an integer value between 0-90 (inclusive).
    // A Backup created under this BackupPlan will NOT be deletable until it
    // reaches Backup's (create_time + backup_delete_lock_days).
    // Updating this field of a BackupPlan does NOT affect existing Backups
    // under it. Backups created AFTER a successful update will inherit
    // the new value.
    //
    // Default: 0 (no delete blocking)
    int32 backup_delete_lock_days = 1;

    // The default maximum age of a Backup created via this BackupPlan.
    // This field MUST be an integer value >= 0 and <= 365.
    // If specified, a Backup created under this BackupPlan will be
    // automatically deleted after its age reaches (create_time +
    // backup_retain_days).
    // If not specified, Backups created under this BackupPlan will NOT be
    // subject to automatic deletion.
    // Updating this field does NOT affect existing Backups under it. Backups
    // created AFTER a successful update will automatically pick up the new
    // value.
    // NOTE: backup_retain_days must be >=
    // [backup_delete_lock_days][google.cloud.gkebackup.v1.BackupPlan.RetentionPolicy.backup_delete_lock_days].
    // If
    // [cron_schedule][google.cloud.gkebackup.v1.BackupPlan.Schedule.cron_schedule]
    // is defined, then this must be
    // <= 360 * the creation interval.
    //
    // Default: 0 (no automatic deletion)
    int32 backup_retain_days = 2;

    // This flag denotes whether the retention policy of this BackupPlan is
    // locked.  If set to True, no further update is allowed on this policy,
    // including the `locked` field itself.
    //
    // Default: False
    bool locked = 3;
  }

  // Schedule defines scheduling parameters for automatically creating Backups
  // via this BackupPlan.
  message Schedule {
    // A standard [cron](https://wikipedia.com/wiki/cron) string that defines a
    // repeating schedule for creating Backups via this BackupPlan. If this is
    // defined, then
    // [backup_retain_days][google.cloud.gkebackup.v1.BackupPlan.RetentionPolicy.backup_retain_days]
    // must also be defined.
    //
    // Default (empty): no automatic backup creation will occur.
    string cron_schedule = 1;

    // This flag denotes whether automatic Backup creation is paused for this
    // BackupPlan.
    //
    // Default: False
    bool paused = 2;
  }

  // BackupConfig defines the configuration of Backups created via this
  // BackupPlan.
  message BackupConfig {
    // This defines the "scope" of the Backup - which namespaced
    // resources in the cluster will be included in a Backup.
    // Exactly one of the fields of backup_scope MUST be specified.
    oneof backup_scope {
      // If True, include all namespaced resources
      bool all_namespaces = 1;

      // If set, include just the resources in the listed namespaces.
      Namespaces selected_namespaces = 2;

      // If set, include just the resources referenced by the listed
      // ProtectedApplications.
      NamespacedNames selected_applications = 3;
    }

    // This flag specifies whether volume data should be backed up when
    // PVCs are included in the scope of a Backup.
    //
    // Default: False
    bool include_volume_data = 4;

    // This flag specifies whether Kubernetes Secret resources should be
    // included when they fall into the scope of Backups.
    //
    // Default: False
    bool include_secrets = 5;

    // This defines a customer managed encryption key that will be used to
    // encrypt the "config" portion (the Kubernetes resources) of Backups
    // created via this plan.
    //
    // Default (empty): Config backup artifacts will not be encrypted.
    EncryptionKey encryption_key = 6;
  }

  // Output only. The full name of the BackupPlan resource.
  // Format: `projects/*/locations/*/backupPlans/*`
  string name = 1;

  // Output only. Server generated global unique identifier of
  // [UUID](https://en.wikipedia.org/wiki/Universally_unique_identifier) format.
  string uid = 2;

  // Output only. The timestamp when this BackupPlan resource was created.
  google.protobuf.Timestamp create_time = 3;

  // Output only. The timestamp when this BackupPlan resource was last
  // updated.
  google.protobuf.Timestamp update_time = 4;

  // User specified descriptive string for this BackupPlan.
  string description = 5;

  // Required. Immutable. The source cluster from which Backups will be created
  // via this BackupPlan. Valid formats:
  //
  // - `projects/*/locations/*/clusters/*`
  // - `projects/*/zones/*/clusters/*`
  string cluster = 6;

  // RetentionPolicy governs lifecycle of Backups created under this plan.
  RetentionPolicy retention_policy = 7;

  // A set of custom labels supplied by user.
  map<string, string> labels = 8;

  // Defines a schedule for automatic Backup creation via this BackupPlan.
  Schedule backup_schedule = 9;

  // Output only. `etag` is used for optimistic concurrency control as a way to
  // help prevent simultaneous updates of a backup plan from overwriting each
  // other. It is strongly suggested that systems make use of the 'etag' in the
  // read-modify-write cycle to perform BackupPlan updates in order to avoid
  // race conditions: An `etag` is returned in the response to `GetBackupPlan`,
  // and systems are expected to put that etag in the request to
  // `UpdateBackupPlan` or `DeleteBackupPlan` to ensure that their change
  // will be applied to the same version of the resource.
  string etag = 10;

  // This flag indicates whether this BackupPlan has been deactivated.
  // Setting this field to True locks the BackupPlan such that no further
  // updates will be allowed (except deletes), including the deactivated field
  // itself. It also prevents any new Backups from being created via this
  // BackupPlan (including scheduled Backups).
  //
  // Default: False
  bool deactivated = 11;

  // Defines the configuration of Backups created via this BackupPlan.
  BackupConfig backup_config = 12;

  // Output only. The number of Kubernetes Pods backed up in the
  // last successful Backup created via this BackupPlan.
  int32 protected_pod_count = 13;
}

// Represents both a request to Restore some portion of a Backup into
// a target GKE cluster and a record of the restore operation itself.
// Next id: 18
message Restore {
  // Possible values for state of the Restore.
  enum State {
    // The Restore resource is in the process of being created.
    STATE_UNSPECIFIED = 0;

    // The Restore resource has been created and the associated RestoreJob
    // Kubernetes resource has been injected into target cluster.
    CREATING = 1;

    // The gkebackup agent in the cluster has begun executing the restore
    // operation.
    IN_PROGRESS = 2;

    // The restore operation has completed successfully. Restored workloads may
    // not yet be operational.
    SUCCEEDED = 3;

    // The restore operation has failed.
    FAILED = 4;

    // This Restore resource is in the process of being deleted.
    DELETING = 5;
  }

  // Output only. The full name of the Restore resource.
  // Format: `projects/*/locations/*/restorePlans/*/restores/*`
  string name = 1;

  // Output only. Server generated global unique identifier of
  // [UUID](https://en.wikipedia.org/wiki/Universally_unique_identifier) format.
  string uid = 2;

  // Output only. The timestamp when this Restore resource was created.
  google.protobuf.Timestamp create_time = 3;

  // Output only. The timestamp when this Restore resource was last
  // updated.
  google.protobuf.Timestamp update_time = 4;

  // User specified descriptive string for this Restore.
  string description = 5;

  // Required. Immutable. A reference to the
  // [Backup][google.cloud.gkebackup.v1.Backup] used as the source from which
  // this Restore will restore. Note that this Backup must be a sub-resource of
  // the RestorePlan's
  // [backup_plan][google.cloud.gkebackup.v1.RestorePlan.backup_plan]. Format:
  // `projects/*/locations/*/backupPlans/*/backups/*`.
  string backup = 6;

  // Output only. The target cluster into which this Restore will restore data.
  // Valid formats:
  //
  //   - `projects/*/locations/*/clusters/*`
  //   - `projects/*/zones/*/clusters/*`
  //
  // Inherited from parent RestorePlan's
  // [cluster][google.cloud.gkebackup.v1.RestorePlan.cluster] value.
  string cluster = 7;

  // Output only. Configuration of the Restore.  Inherited from parent
  // RestorePlan's
  // [restore_config][google.cloud.gkebackup.v1.RestorePlan.restore_config].
  RestoreConfig restore_config = 8;

  // A set of custom labels supplied by user.
  map<string, string> labels = 9;

  // Output only. The current state of the Restore.
  State state = 10;

  // Output only. Human-readable description of why the Restore is in its
  // current state.
  string state_reason = 11;

  // Output only. Timestamp of when the restore operation completed.
  google.protobuf.Timestamp complete_time = 12;

  // Output only. Number of resources restored during the restore execution.
  int32 resources_restored_count = 13;

  // Output only. Number of resources excluded during the restore execution.
  int32 resources_excluded_count = 14;

  // Output only. Number of resources that failed to be restored during the
  // restore execution.
  int32 resources_failed_count = 15;

  // Output only. Number of volumes restored during the restore execution.
  int32 volumes_restored_count = 16;

  // Output only. `etag` is used for optimistic concurrency control as a way to
  // help prevent simultaneous updates of a restore from overwriting each other.
  // It is strongly suggested that systems make use of the `etag` in the
  // read-modify-write cycle to perform restore updates in order to avoid
  // race conditions: An `etag` is returned in the response to `GetRestore`,
  // and systems are expected to put that etag in the request to
  // `UpdateRestore` or `DeleteRestore` to ensure that their change will be
  // applied to the same version of the resource.
  string etag = 17;
}

// Configuration of a restore.
// Next id: 12
message RestoreConfig {
  // This is a direct map to the Kubernetes GroupKind type
  // [GroupKind](https://godoc.org/k8s.io/apimachinery/pkg/runtime/schema#GroupKind)
  // and is used for identifying specific "types" of resources to restore.
  message GroupKind {
    // API group string of a Kubernetes resource, e.g.
    // "apiextensions.k8s.io", "storage.k8s.io", etc.
    // Note: use empty string for core API group
    string resource_group = 1;

    // Kind of a Kubernetes resource, e.g.
    // "CustomResourceDefinition", "StorageClass", etc.
    string resource_kind = 2;
  }

  // Defines the scope of cluster-scoped resources to restore.
  //
  // Some group kinds are not reasonable choices for a restore, and will cause
  // an error if selected here. Any scope selection that would restore
  // "all valid" resources automatically excludes these group kinds.
  // - gkebackup.gke.io/BackupJob
  // - gkebackup.gke.io/RestoreJob
  // - metrics.k8s.io/NodeMetrics
  // - migration.k8s.io/StorageState
  // - migration.k8s.io/StorageVersionMigration
  // - Node
  // - snapshot.storage.k8s.io/VolumeSnapshotContent
  // - storage.k8s.io/CSINode
  //
  // Some group kinds are driven by restore configuration elsewhere,
  // and will cause an error if selected here.
  // - Namespace
  // - PersistentVolume
  message ClusterResourceRestoreScope {
    // A list of cluster-scoped resource group kinds to restore from the
    // backup. If specified, only the selected resources will be restored.
    // Mutually exclusive to any other field in the message.
    repeated GroupKind selected_group_kinds = 1;
  }

  // A transformation rule to be applied against Kubernetes resources as they
  // are selected for restoration from a Backup. A rule contains both filtering
  // logic (which resources are subject to substitution) and substitution logic.
  message SubstitutionRule {
    // (Filtering parameter) Any resource subject to substitution must be
    // contained within one of the listed Kubernetes Namespace in the Backup.
    // If this field is not provided, no namespace filtering will be performed
    // (all resources in all Namespaces, including all cluster-scoped resources,
    // will be candidates for substitution).
    // To mix cluster-scoped and namespaced resources in the same rule, use an
    // empty string ("") as one of the target namespaces.
    repeated string target_namespaces = 1;

    // (Filtering parameter) Any resource subject to substitution must belong to
    // one of the listed "types".
    // If this field is not provided, no type filtering will be performed (all
    // resources of all types matching previous filtering parameters will be
    // candidates for substitution).
    repeated GroupKind target_group_kinds = 2;

    // Required. This is a [JSONPath]
    // (https://kubernetes.io/docs/reference/kubectl/jsonpath/)
    // expression that matches specific fields of candidate
    // resources and it operates as both a filtering parameter (resources that
    // are not matched with this expression will not be candidates for
    // substitution) as well as a field identifier (identifies exactly which
    // fields out of the candidate resources will be modified).
    string target_json_path = 3;

    // (Filtering parameter) This is a [regular expression]
    // (https://en.wikipedia.org/wiki/Regular_expression)
    // that is compared against the fields matched by the target_json_path
    // expression (and must also have passed the previous filters).
    // Substitution will not be performed against fields whose
    // value does not match this expression. If this field is NOT specified,
    // then ALL fields matched by the target_json_path expression will undergo
    // substitution. Note that an empty (e.g., "", rather than unspecified)
    // value for this field will only match empty fields.
    string original_value_pattern = 4;

    // This is the new value to set for any fields that pass the filtering and
    // selection criteria. To remove a value from a Kubernetes resource, either
    // leave this field unspecified, or set it to the empty string ("").
    string new_value = 5;
  }

  // Defines how volume data should be restored
  enum VolumeDataRestorePolicy {
    // Unspecified (illegal).
    VOLUME_DATA_RESTORE_POLICY_UNSPECIFIED = 0;

    // For each PVC to be restored, will create a new underlying volume (and PV)
    // from the corresponding VolumeBackup contained within the Backup.
    RESTORE_VOLUME_DATA_FROM_BACKUP = 1;

    // For each PVC to be restored, attempt to reuse the original PV contained
    // in the Backup (with its original underlying volume).  Note that option
    // is likely only usable when restoring a workload to its original cluster.
    REUSE_VOLUME_HANDLE_FROM_BACKUP = 2;

    // For each PVC to be restored, PVCs will be created without any particular
    // action to restore data.  In this case, the normal Kubernetes provisioning
    // logic would kick in, and this would likely result in either dynamically
    // provisioning blank PVs or binding to statically provisioned PVs.
    NO_VOLUME_DATA_RESTORATION = 3;
  }

  // Defines the behavior for handling the situation where cluster-scoped
  // resources being restored already exist in the target cluster.
  enum ClusterResourceConflictPolicy {
    // Unspecified. Only allowed if no cluster-scoped resources will be
    // restored.
    CLUSTER_RESOURCE_CONFLICT_POLICY_UNSPECIFIED = 0;

    // Do not attempt to restore the conflicting resource.
    USE_EXISTING_VERSION = 1;

    // Delete the existing version before re-creating it from the Backup.
    // Note that this is a dangerous option which could cause unintentional
    // data loss if used inappropriately - for example, deleting a CRD will
    // cause Kubernetes to delete all CRs of that type.
    USE_BACKUP_VERSION = 2;
  }

  // Defines the behavior for handling the situation where sets of namespaced
  // resources being restored already exist in the target cluster.
  enum NamespacedResourceRestoreMode {
    // Unspecified (invalid).
    NAMESPACED_RESOURCE_RESTORE_MODE_UNSPECIFIED = 0;

    // When conflicting top-level resources (either Namespaces or
    // ProtectedApplications, depending upon the scope) are encountered, this
    // will first trigger a delete of the conflicting resource AND ALL OF ITS
    // REFERENCED RESOURCES (e.g., all resources in the Namespace or all
    // resources referenced by the ProtectedApplication) before restoring the
    // resources from the Backup. This mode should only be used when you are
    // intending to revert some portion of a cluster to an earlier state.
    DELETE_AND_RESTORE = 1;

    // If conflicting top-level resources (either Namespaces or
    // ProtectedApplications, depending upon the scope) are encountered at the
    // beginning of a restore process, the Restore will fail.  If a conflict
    // occurs during the restore process itself (e.g., because an out of band
    // process creates conflicting resources), a conflict will be reported.
    FAIL_ON_CONFLICT = 2;
  }

  // Specifies the mechanism to be used to restore volume data.
  // Default: VOLUME_DATA_RESTORE_POLICY_UNSPECIFIED (will be treated as
  // NO_VOLUME_DATA_RESTORATION).
  VolumeDataRestorePolicy volume_data_restore_policy = 1;

  // Defines the behavior for handling the situation where cluster-scoped
  // resources being restored already exist in the target cluster. This MUST be
  // set to a value other than CLUSTER_RESOURCE_CONFLICT_POLICY_UNSPECIFIED if
  // [cluster_resource_restore_scope][google.cloud.gkebackup.v1.RestoreConfig.cluster_resource_restore_scope]
  // is not empty.
  ClusterResourceConflictPolicy cluster_resource_conflict_policy = 2;

  // Defines the behavior for handling the situation where sets of namespaced
  // resources being restored already exist in the target cluster. This MUST be
  // set to a value other than NAMESPACED_RESOURCE_RESTORE_MODE_UNSPECIFIED.
  NamespacedResourceRestoreMode namespaced_resource_restore_mode = 3;

  // Identifies the cluster-scoped resources to restore from the Backup.
  // Not specifying it means NO cluster resource will be restored.
  ClusterResourceRestoreScope cluster_resource_restore_scope = 4;

  // Specifies the namespaced resources to restore from the Backup.
  // Only one of the entries may be specified. If not specified, NO namespaced
  // resources will be restored.
  //
  // Note: Resources will never be restored into *managed* namespaces such as
  // `kube-system`, `kube-public`, or `kube-node-lease`. These namespaces
  // are silently skipped when
  // [all_namespaces][google.cloud.gkebackup.v1.RestoreConfig.all_namespaces] is
  // selected. Listing them explicitly will result in an error.
  oneof namespaced_resource_restore_scope {
    // Restore all namespaced resources in the Backup if set to "True".
    // Specifying this field to "False" is an error.
    bool all_namespaces = 5;

    // A list of selected Namespaces to restore from the Backup. The listed
    // Namespaces and all resources contained in them will be restored.
    Namespaces selected_namespaces = 6;

    // A list of selected ProtectedApplications to restore. The listed
    // ProtectedApplications and all the resources to which they refer will be
    // restored.
    NamespacedNames selected_applications = 7;
  }

  // A list of transformation rules to be applied against Kubernetes resources
  // as they are selected for restoration from a Backup. Rules are executed in
  // order defined - this order matters, as changes made by a rule may impact
  // the filtering logic of subsequent rules. An empty list means no
  // substitution will occur.
  repeated SubstitutionRule substitution_rules = 8;
}

// The configuration of a potential series of Restore operations to be performed
// against Backups belong to a particular BackupPlan.
// Next id: 13
message RestorePlan {
  // Output only. The full name of the RestorePlan resource.
  // Format: `projects/*/locations/*/restorePlans/*`.
  string name = 1;

  // Output only. Server generated global unique identifier of
  // [UUID](https://en.wikipedia.org/wiki/Universally_unique_identifier) format.
  string uid = 2;

  // Output only. The timestamp when this RestorePlan resource was
  // created.
  google.protobuf.Timestamp create_time = 3;

  // Output only. The timestamp when this RestorePlan resource was last
  // updated.
  google.protobuf.Timestamp update_time = 4;

  // User specified descriptive string for this RestorePlan.
  string description = 5;

  // Required. Immutable. A reference to the
  // [BackupPlan][google.cloud.gkebackup.v1.BackupPlan] from which Backups may
  // be used as the source for Restores created via this RestorePlan. Format:
  // `projects/*/locations/*/backupPlans/*`.
  string backup_plan = 6;

  // Required. Immutable. The target cluster into which Restores created via
  // this RestorePlan will restore data. NOTE: the cluster's region must be the
  // same as the RestorePlan. Valid formats:
  //
  //   - `projects/*/locations/*/clusters/*`
  //   - `projects/*/zones/*/clusters/*`
  string cluster = 7;

  // Required. Configuration of Restores created via this RestorePlan.
  RestoreConfig restore_config = 8;

  // A set of custom labels supplied by user.
  map<string, string> labels = 9;

  // Output only. `etag` is used for optimistic concurrency control as a way to
  // help prevent simultaneous updates of a restore from overwriting each other.
  // It is strongly suggested that systems make use of the `etag` in the
  // read-modify-write cycle to perform restore updates in order to avoid
  // race conditions: An `etag` is returned in the response to `GetRestorePlan`,
  // and systems are expected to put that etag in the request to
  // `UpdateRestorePlan` or `DeleteRestorePlan` to ensure that their change
  // will be applied to the same version of the resource.
  string etag = 10;
}

// The data within all RestorePlan events.
message RestorePlanEventData {
  // Optional. The RestorePlan event payload. Unset for deletion events.
  optional RestorePlan payload = 1;
}

// The data within all Backup events.
message BackupEventData {
  // Optional. The Backup event payload. Unset for deletion events.
  optional Backup payload = 1;
}

// The data within all BackupPlan events.
message BackupPlanEventData {
  // Optional. The BackupPlan event payload. Unset for deletion events.
  optional BackupPlan payload = 1;
}

// The data within all Restore events.
message RestoreEventData {
  // Optional. The Restore event payload. Unset for deletion events.
  optional Restore payload = 1;
}