Merge branch 'main' into refactor-e2e-test-setup

Author: johscheuer

api/v1beta2/foundationdb_process_class.go

@@ -27,6 +27,8 @@ import (
 // ProcessClass models the class of a pod
 type ProcessClass string
 
+// See https://github.com/apple/foundationdb/blob/release-7.1/fdbrpc/Locality.cpp for additional information regarding the
+// process classes and process roles.
 const (
 	// ProcessClassStorage model for FDB class storage
 	ProcessClassStorage ProcessClass = "storage"
@@ -50,6 +52,8 @@ const (
 	ProcessClassCommitProxy ProcessClass = "commit_proxy"
 	// ProcessClassGrvProxy model for FDB grv_proxy processes
 	ProcessClassGrvProxy ProcessClass = "grv_proxy"
+	// ProcessClassBackup model for FDB backup processes
+	ProcessClassBackup ProcessClass = "backup"
 )
 
 // IsStateful determines whether a process class should store data.

api/v1beta2/foundationdbbackup_types.go

@@ -117,8 +117,30 @@ type FoundationDBBackupSpec struct {
 	// +kubebuilder:validation:Enum=split;unified
 	// +kubebuilder:default:=split
 	ImageType *ImageType `json:"imageType,omitempty"`
+
+	// BackupType defines the backup type that should be used for the backup. When the BackupType is set to
+	// BackupTypePartitionedLog, it's expected that the FoundationDBCluster creates and manages the additional
+	// backup worker processes. A migration to a different backup type is not yet supported in the operator.
+	// Default: "backup_agent".
+	// +kubebuilder:validation:Optional
+	// +kubebuilder:validation:Enum=backup_agent;partitioned_log
+	// +kubebuilder:default:=backup_agent
+	BackupType *BackupType `json:"backupType,omitempty"`
 }
 
+// BackupType defines the backup type that should be used for the backup.
+// +kubebuilder:validation:MaxLength=64
+type BackupType string
+
+const (
+	// BackupTypeDefault refers to the current default backup type with additional backup agents.
+	BackupTypeDefault BackupType = "backup_agent"
+
+	// BackupTypePartitionedLog refers to the new partitioned log backup system, see
+	// https://github.com/apple/foundationdb/blob/main/design/backup_v2_partitioned_logs.md.
+	BackupTypePartitionedLog BackupType = "partitioned_log"
+)
+
 // FoundationDBBackupStatus describes the current status of the backup for a cluster.
 type FoundationDBBackupStatus struct {
 	// AgentCount provides the number of agents that are up-to-date, ready,
@@ -279,6 +301,18 @@ type FoundationDBLiveBackupStatus struct {
 type FoundationDBLiveBackupStatusState struct {
 	// Running determines whether the backup is currently running.
 	Running bool `json:"Running,omitempty"`
+
+	// Restorable if true, the backup can be restored
+	Restorable *bool `json:"Restorable,omitempty"`
+
+	// LatestRestorablePoint contains information about the latest restorable point if any exists.
+	LatestRestorablePoint *LatestRestorablePoint `json:"LatestRestorablePoint,omitempty"`
+}
+
+// LatestRestorablePoint contains information about the latest restorable point if any exists.
+type LatestRestorablePoint struct {
+	// Version is the version that can be restored to.
+	Version *uint64 `json:"Version,omitempty"`
 }
 
 // GetDesiredAgentCount determines how many backup agents we should run
@@ -331,11 +365,34 @@ func (backup *FoundationDBBackup) CheckReconciliation() (bool, error) {
 	return reconciled, nil
 }
 
+// GetBackupType returns the backup type for the backup.
+func (backup *FoundationDBBackup) GetBackupType() BackupType {
+	if backup.Spec.BackupType != nil {
+		return *backup.Spec.BackupType
+	}
+
+	return BackupTypeDefault
+}
+
 // GetAllowTagOverride returns the bool value for AllowTagOverride
 func (foundationDBBackupSpec *FoundationDBBackupSpec) GetAllowTagOverride() bool {
 	return ptr.Deref(foundationDBBackupSpec.AllowTagOverride, false)
 }
 
+// GetEncryptionKey returns the encryption key path if the current version supports encrypted backups.
+func (backup *FoundationDBBackup) GetEncryptionKey() (string, error) {
+	fdbVersion, err := ParseFdbVersion(backup.Spec.Version)
+	if err != nil {
+		return "", err
+	}
+
+	if !fdbVersion.SupportsBackupEncryption() {
+		return "", nil
+	}
+
+	return backup.Spec.EncryptionKeyPath, nil
+}
+
 // UseUnifiedImage returns true if the unified image should be used.
 func (backup *FoundationDBBackup) UseUnifiedImage() bool {
 	imageType := ImageTypeSplit

api/v1beta2/zz_generated.deepcopy.go

@@ -71,6 +71,13 @@ spec:
                 - Stopped
                 - Paused
                 type: string
+              backupType:
+                default: backup_agent
+                enum:
+                - backup_agent
+                - partitioned_log
+                maxLength: 64
+                type: string
               blobStoreConfiguration:
                 properties:
                   accountName:

config/crd/bases/apps.foundationdb.org_foundationdbbackups.yaml

@@ -188,14 +188,21 @@ var _ = Describe("admin_client_test", func() {
 			})
 		})
 
-		Context("with a backup running", func() {
+		When("a backup running is running", func() {
+			var backup *fdbv1beta2.FoundationDBBackup
+
 			BeforeEach(func() {
-				err = mockAdminClient.StartBackup(
-					"blobstore://test@test-service/test-backup",
-					10,
-					"",
-				)
-				Expect(err).NotTo(HaveOccurred())
+				backup = &fdbv1beta2.FoundationDBBackup{
+					Spec: fdbv1beta2.FoundationDBBackupSpec{
+						BlobStoreConfiguration: &fdbv1beta2.BlobStoreConfiguration{
+							BackupName:  "test-backup",
+							AccountName: "test",
+						},
+						SnapshotPeriodSeconds: ptr.To(10),
+					},
+				}
+
+				Expect(mockAdminClient.StartBackup(backup)).To(Succeed())
 			})
 
 			It("should put the backup in the layer status", func() {
@@ -204,7 +211,7 @@ var _ = Describe("admin_client_test", func() {
 					status.Cluster.Layers.Backup.Tags,
 				).To(Equal(map[string]fdbv1beta2.FoundationDBStatusBackupTag{
 					"default": {
-						CurrentContainer: "blobstore://test@test-service/test-backup",
+						CurrentContainer: backup.BackupURL(),
 						RunningBackup:    ptr.To(true),
 						Restorable:       ptr.To(true),
 					},
@@ -213,8 +220,7 @@ var _ = Describe("admin_client_test", func() {
 
 			Context("with a paused backup", func() {
 				BeforeEach(func() {
-					err = mockAdminClient.PauseBackups()
-					Expect(err).NotTo(HaveOccurred())
+					Expect(mockAdminClient.PauseBackups()).To(Succeed())
 				})
 
 				It("should mark the backup as paused", func() {
@@ -224,10 +230,8 @@ var _ = Describe("admin_client_test", func() {
 
 			Context("with an resume backup", func() {
 				BeforeEach(func() {
-					err = mockAdminClient.PauseBackups()
-					Expect(err).NotTo(HaveOccurred())
-					err = mockAdminClient.ResumeBackups()
-					Expect(err).NotTo(HaveOccurred())
+					Expect(mockAdminClient.PauseBackups()).To(Succeed())
+					Expect(mockAdminClient.ResumeBackups()).To(Succeed())
 				})
 
 				It("should mark the backup as not paused", func() {
@@ -237,16 +241,15 @@ var _ = Describe("admin_client_test", func() {
 
 			Context("with a stopped backup", func() {
 				BeforeEach(func() {
-					err = mockAdminClient.StopBackup("blobstore://test@test-service/test-backup")
-					Expect(err).NotTo(HaveOccurred())
+					Expect(mockAdminClient.StopBackup(backup)).To(Succeed())
 				})
 
 				It("should mark the backup as stopped", func() {
 					Expect(
 						status.Cluster.Layers.Backup.Tags,
 					).To(Equal(map[string]fdbv1beta2.FoundationDBStatusBackupTag{
 						"default": {
-							CurrentContainer: "blobstore://test@test-service/test-backup",
+							CurrentContainer: backup.BackupURL(),
 							RunningBackup:    ptr.To(false),
 							Restorable:       ptr.To(true),
 						},
@@ -258,6 +261,8 @@ var _ = Describe("admin_client_test", func() {
 
 	Describe("backup status", func() {
 		var status *fdbv1beta2.FoundationDBLiveBackupStatus
+		var backup *fdbv1beta2.FoundationDBBackup
+
 		JustBeforeEach(func() {
 			status, err = mockAdminClient.GetBackupStatus()
 			Expect(err).NotTo(HaveOccurred())
@@ -273,16 +278,21 @@ var _ = Describe("admin_client_test", func() {
 
 		Context("with a backup running", func() {
 			BeforeEach(func() {
-				err = mockAdminClient.StartBackup(
-					"blobstore://test@test-service/test-backup",
-					10,
-					"",
-				)
-				Expect(err).NotTo(HaveOccurred())
+				backup = &fdbv1beta2.FoundationDBBackup{
+					Spec: fdbv1beta2.FoundationDBBackupSpec{
+						BlobStoreConfiguration: &fdbv1beta2.BlobStoreConfiguration{
+							BackupName:  "test-backup",
+							AccountName: "test",
+						},
+						SnapshotPeriodSeconds: ptr.To(10),
+					},
+				}
+
+				Expect(mockAdminClient.StartBackup(backup)).To(Succeed())
 			})
 
 			It("should put the backup in the status", func() {
-				Expect(status.DestinationURL).To(Equal("blobstore://test@test-service/test-backup"))
+				Expect(status.DestinationURL).To(Equal(backup.BackupURL()))
 				Expect(status.Status.Running).To(BeTrue())
 				Expect(status.BackupAgentsPaused).To(BeFalse())
 				Expect(status.SnapshotIntervalSeconds).To(Equal(10))
@@ -301,10 +311,8 @@ var _ = Describe("admin_client_test", func() {
 
 			Context("with a resumed backup", func() {
 				BeforeEach(func() {
-					err = mockAdminClient.PauseBackups()
-					Expect(err).NotTo(HaveOccurred())
-					err = mockAdminClient.ResumeBackups()
-					Expect(err).NotTo(HaveOccurred())
+					Expect(mockAdminClient.PauseBackups()).To(Succeed())
+					Expect(mockAdminClient.ResumeBackups()).To(Succeed())
 				})
 
 				It("should mark the backup as not paused", func() {
@@ -314,8 +322,7 @@ var _ = Describe("admin_client_test", func() {
 
 			Context("with a stopped backup", func() {
 				BeforeEach(func() {
-					err = mockAdminClient.StopBackup("blobstore://test@test-service/test-backup")
-					Expect(err).NotTo(HaveOccurred())
+					Expect(mockAdminClient.StopBackup(backup)).To(Succeed())
 				})
 
 				It("should mark the backup as stopped", func() {
@@ -325,12 +332,14 @@ var _ = Describe("admin_client_test", func() {
 
 			Context("with a modification to the snapshot time", func() {
 				BeforeEach(func() {
-					err = mockAdminClient.ModifyBackup(20)
-					Expect(err).NotTo(HaveOccurred())
+					backup.Spec.SnapshotPeriodSeconds = ptr.To(20)
+					Expect(mockAdminClient.ModifyBackup(backup)).NotTo(HaveOccurred())
 				})
 
 				It("should mark the backup as stopped", func() {
-					Expect(status.SnapshotIntervalSeconds).To(Equal(20))
+					Expect(
+						status.SnapshotIntervalSeconds,
+					).To(BeNumerically("==", backup.SnapshotPeriodSeconds()))
 				})
 			})
 		})

controllers/admin_client_test.go

@@ -41,8 +41,7 @@ func (s modifyBackup) reconcile(
 		return nil
 	}
 
-	snapshotPeriod := backup.SnapshotPeriodSeconds()
-	if backup.Status.BackupDetails.SnapshotPeriodSeconds != snapshotPeriod {
+	if backup.Status.BackupDetails.SnapshotPeriodSeconds != backup.SnapshotPeriodSeconds() {
 		adminClient, err := r.adminClientForBackup(ctx, backup)
 		if err != nil {
 			return &requeue{curError: err}
@@ -51,7 +50,7 @@ func (s modifyBackup) reconcile(
 			_ = adminClient.Close()
 		}()
 
-		err = adminClient.ModifyBackup(snapshotPeriod)
+		err = adminClient.ModifyBackup(backup)
 		if err != nil {
 			return &requeue{curError: err}
 		}

controllers/modify_backup.go

@@ -49,11 +49,7 @@ func (s startBackup) reconcile(
 		_ = adminClient.Close()
 	}()
 
-	err = adminClient.StartBackup(
-		backup.BackupURL(),
-		backup.SnapshotPeriodSeconds(),
-		backup.Spec.EncryptionKeyPath,
-	)
+	err = adminClient.StartBackup(backup)
 	if err != nil {
 		return &requeue{curError: err}
 	}

controllers/start_backup.go

@@ -49,7 +49,7 @@ func (s stopBackup) reconcile(
 		_ = adminClient.Close()
 	}()
 
-	err = adminClient.StopBackup(backup.BackupURL())
+	err = adminClient.StopBackup(backup)
 	if err != nil {
 		return &requeue{curError: err}
 	}

controllers/stop_backup.go

@@ -44,8 +44,8 @@ func (updateMetadata) reconcile(
 ) *requeue {
 	var shouldRequeue bool
 	for _, processGroup := range cluster.Status.ProcessGroups {
-		if processGroup.IsMarkedForRemoval() {
-			logger.V(1).Info("Ignore process group marked for removal",
+		if processGroup.GetConditionTime(fdbv1beta2.ResourcesTerminating) != nil {
+			logger.V(1).Info("Ignore process group that is stuck in terminating state",
 				"processGroupID", processGroup.ProcessGroupID)
 			continue
 		}