mark the BackupRestore as Failed if the StorageBackup is failed state

internal/controller/backuprestore_controller.go

@@ -50,6 +50,7 @@ const (
 const (
 	eventReasonRestoreBackupNotFound     = "RestoreBackupNotFound"
 	eventReasonRestoreBackupNotReady     = "RestoreBackupNotReady"
+	eventReasonRestoreBackupFailed       = "RestoreBackupFailed"
 	eventReasonRestoreClusterLookupError = "RestoreClusterLookupError"
 	eventReasonRestorePoolLookupError    = "RestorePoolLookupError"
 	eventReasonRestoreAPIFailed          = "RestoreAPIFailed"
@@ -212,6 +213,20 @@ func (r *BackupRestoreReconciler) reconcileBackupAndPool(
 		return ctrl.Result{RequeueAfter: restoreReconcileRequeue}, true, nil
 	}
 
+	// Mark the BackupRestore as Failed if the StorageBackup is in terminal state Failed.
+	if backup.Status.Phase == simplyblockv1alpha1.BackupPhaseFailed {
+		msg := fmt.Sprintf("StorageBackup %q failed and cannot be restored: %s",
+			backup.Name, backup.Status.Message)
+		if patchErr := r.patchStatus(ctx, restoreCR, func(s *simplyblockv1alpha1.BackupRestoreStatus) {
+			s.Phase = simplyblockv1alpha1.RestorePhaseFailed
+			s.Message = msg
+		}); patchErr != nil {
+			return ctrl.Result{}, true, patchErr
+		}
+		r.Recorder.Eventf(restoreCR, corev1.EventTypeWarning, eventReasonRestoreBackupFailed, "%s", msg)
+		return ctrl.Result{}, true, nil
+	}
+
 	if backup.Status.Phase != simplyblockv1alpha1.BackupPhaseDone {
 		msg := fmt.Sprintf("StorageBackup %q is not ready (phase=%s)", backup.Name, backup.Status.Phase)
 		if patchErr := r.patchStatus(ctx, restoreCR, func(s *simplyblockv1alpha1.BackupRestoreStatus) {

internal/controller/backuprestore_controller_test.go

@@ -10,6 +10,9 @@ import (
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/resource"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/client-go/tools/record"
+	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 
 	simplyblockv1alpha1 "github.com/simplyblock/simplyblock-operator/api/v1alpha1"
@@ -150,6 +153,77 @@ func TestBackupRestoreEnsurePVIncludesCSIAttributes(t *testing.T) {
 	}
 }
 
+// TestBackupRestoreFailsWhenBackupIsFailed verifies that a BackupRestore referencing a
+// StorageBackup stuck in a terminal Failed phase is itself marked Failed (with no further
+// requeue), rather than looping in Pending forever.
+func TestBackupRestoreFailsWhenBackupIsFailed(t *testing.T) {
+	scheme := newTestScheme(t, corev1.AddToScheme, simplyblockv1alpha1.AddToScheme)
+
+	cluster := testCluster("default", "mycluster", "cluster-uuid")
+	backup := &simplyblockv1alpha1.StorageBackup{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "backup-sample",
+			Namespace: "default",
+		},
+		Status: simplyblockv1alpha1.StorageBackupStatus{
+			Phase:   simplyblockv1alpha1.BackupPhaseFailed,
+			Message: "Snapshot snap-1 not found",
+		},
+	}
+	restore := &simplyblockv1alpha1.BackupRestore{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "restore-sample",
+			Namespace: "default",
+		},
+		Spec: simplyblockv1alpha1.BackupRestoreSpec{
+			ClusterName: "mycluster",
+			BackupRef:   simplyblockv1alpha1.BackupRef{Name: "backup-sample"},
+			PVCTemplate: simplyblockv1alpha1.PVCTemplate{
+				Spec: corev1.PersistentVolumeClaimSpec{
+					AccessModes: []corev1.PersistentVolumeAccessMode{corev1.ReadWriteOnce},
+					Resources: corev1.VolumeResourceRequirements{
+						Requests: corev1.ResourceList{
+							corev1.ResourceStorage: resourceMustParse(t, "10Gi"),
+						},
+					},
+				},
+			},
+		},
+	}
+
+	k8sClient := newTestClient(t, scheme,
+		[]client.Object{&simplyblockv1alpha1.BackupRestore{}},
+		cluster, backup, restore,
+	)
+
+	r := &BackupRestoreReconciler{
+		Client:   k8sClient,
+		Scheme:   scheme,
+		Recorder: record.NewFakeRecorder(10),
+	}
+
+	res, err := r.Reconcile(context.Background(), ctrl.Request{
+		NamespacedName: types.NamespacedName{Name: "restore-sample", Namespace: "default"},
+	})
+	if err != nil {
+		t.Fatalf("Reconcile returned error: %v", err)
+	}
+	if res.RequeueAfter != 0 {
+		t.Fatalf("RequeueAfter = %v, want 0 (restore must terminate, not poll forever)", res.RequeueAfter)
+	}
+
+	got := &simplyblockv1alpha1.BackupRestore{}
+	if err := k8sClient.Get(context.Background(), client.ObjectKey{Name: "restore-sample", Namespace: "default"}, got); err != nil {
+		t.Fatalf("failed to get restore: %v", err)
+	}
+	if got.Status.Phase != simplyblockv1alpha1.RestorePhaseFailed {
+		t.Fatalf("Phase = %q, want %q", got.Status.Phase, simplyblockv1alpha1.RestorePhaseFailed)
+	}
+	if !strings.Contains(got.Status.Message, "Snapshot snap-1 not found") {
+		t.Fatalf("Message = %q, want it to include the backup's failure reason", got.Status.Message)
+	}
+}
+
 func resourceMustParse(t *testing.T, value string) resource.Quantity {
 	t.Helper()