Add Watch of Velero Backup and remove Backup controller

Change which removes Backup Controller and adds the Watch of the
Backup object within NonAdminBackup Controller.

Added two main predicates with 'upper' logic within composite
predicate to easily distinguish between predicate for NonAdminBackup
and the Backup one.

The reconcile loop updates the Status and the Spec of the NonAdminBackup
from the Velero Backup object. The Spec in the Velero Backup is updated
by the Velero, so we use similar logic to update our NonAdminBackup one.

Signed-off-by: Michal Pryc <[email protected]>

PROJECT

@@ -17,9 +17,4 @@ resources:
   kind: NonAdminBackup
   path: github.com/migtools/oadp-non-admin/api/v1alpha1
   version: v1alpha1
-- controller: true
-  domain: oadp.openshift.io
-  group: nac.oadp.openshift.io
-  kind: VeleroBackup
-  version: v1alpha1
 version: "3"

cmd/main.go

@@ -135,14 +135,6 @@ func main() {
 	}
 	//+kubebuilder:scaffold:builder
 
-	if err = (&controller.VeleroBackupReconciler{
-		Client: mgr.GetClient(),
-		Scheme: mgr.GetScheme(),
-	}).SetupWithManager(mgr); err != nil {
-		setupLog.Error(err, "unable to create controller", "controller", "VeleroBackup")
-		os.Exit(1)
-	}
-
 	if err := mgr.AddHealthzCheck("healthz", healthz.Ping); err != nil {
 		setupLog.Error(err, "unable to set up health check")
 		os.Exit(1)

config/rbac/role.yaml

@@ -36,7 +36,6 @@ rules:
   - backups
   verbs:
   - create
-  - delete
   - get
   - list
   - patch

internal/controller/common_nab.go

@@ -1,11 +1,15 @@
 package controller
 
 import (
+	"context"
 	"crypto/sha1"
 	"encoding/hex"
 	"fmt"
+	"reflect"
 
+	"github.com/go-logr/logr"
 	velerov1api "github.com/vmware-tanzu/velero/pkg/apis/velero/v1"
+	"sigs.k8s.io/controller-runtime/pkg/client"
 
 	nacv1alpha1 "github.com/migtools/oadp-non-admin/api/v1alpha1"
 )
@@ -48,3 +52,26 @@ func GenerateVeleroBackupName(namespace, nabName string) string {
 
 	return veleroBackupName
 }
+
+func UpdateNonAdminBackupFromVeleroBackup(ctx context.Context, r client.Client, log logr.Logger, nab *nacv1alpha1.NonAdminBackup, veleroBackup *velerov1api.Backup) error {
+	// Make a copy of the current status for comparison
+	oldStatus := nab.Spec.BackupStatus.DeepCopy()
+	oldSpec := nab.Spec.BackupSpec.DeepCopy()
+
+	// Update the status & spec
+	nab.Spec.BackupStatus = &veleroBackup.Status
+	nab.Spec.BackupSpec = &veleroBackup.Spec
+
+	if reflect.DeepEqual(oldStatus, nab.Spec.BackupStatus) && reflect.DeepEqual(oldSpec, nab.Spec.BackupSpec) {
+		// No change, no need to update
+		log.V(1).Info("NonAdminBackup status and spec is already up to date")
+		return nil
+	}
+
+	if err := r.Update(ctx, nab); err != nil {
+		log.Error(err, "Failed to update NonAdminBackup")
+		return err
+	}
+
+	return nil
+}

internal/controller/composite_predicate.go

@@ -0,0 +1,51 @@
+// composite_predicate.go
+
+package controller
+
+import (
+	"context"
+
+	"sigs.k8s.io/controller-runtime/pkg/event"
+)
+
+type CompositePredicate struct {
+	NonAdminBackupPredicate NonAdminBackupPredicate
+	VeleroBackupPredicate   VeleroBackupPredicate
+	Context                 context.Context
+}
+
+func (p CompositePredicate) Create(evt event.CreateEvent) bool {
+	// If NonAdminBackupPredicate returns true, ignore VeleroBackupPredicate
+	if p.NonAdminBackupPredicate.Create(p.Context, evt) {
+		return true
+	}
+	// Otherwise, apply VeleroBackupPredicate
+	return p.VeleroBackupPredicate.Create(p.Context, evt)
+}
+
+func (p CompositePredicate) Update(evt event.UpdateEvent) bool {
+	// If NonAdminBackupPredicate returns true, ignore VeleroBackupPredicate
+	if p.NonAdminBackupPredicate.Update(p.Context, evt) {
+		return true
+	}
+	// Otherwise, apply VeleroBackupPredicate
+	return p.VeleroBackupPredicate.Update(p.Context, evt)
+}
+
+func (p CompositePredicate) Delete(evt event.DeleteEvent) bool {
+	// If NonAdminBackupPredicate returns true, ignore VeleroBackupPredicate
+	if p.NonAdminBackupPredicate.Delete(p.Context, evt) {
+		return true
+	}
+	// Otherwise, apply VeleroBackupPredicate
+	return p.VeleroBackupPredicate.Delete(p.Context, evt)
+}
+
+func (p CompositePredicate) Generic(evt event.GenericEvent) bool {
+	// If NonAdminBackupPredicate returns true, ignore VeleroBackupPredicate
+	if p.NonAdminBackupPredicate.Generic(p.Context, evt) {
+		return true
+	}
+	// Otherwise, apply VeleroBackupPredicate
+	return p.VeleroBackupPredicate.Generic(p.Context, evt)
+}

internal/controller/nonadminbackup_controller.go

@@ -47,6 +47,8 @@ type NonAdminBackupReconciler struct {
 //+kubebuilder:rbac:groups=nac.oadp.openshift.io,resources=nonadminbackups/status,verbs=get;update;patch
 //+kubebuilder:rbac:groups=nac.oadp.openshift.io,resources=nonadminbackups/finalizers,verbs=update
 
+//+kubebuilder:rbac:groups=velero.io,resources=backups,verbs=get;list;watch;create;update;patch
+
 // Reconcile is part of the main kubernetes reconciliation loop which aims to
 // move the current state of the cluster closer to the desired state.
 // TODO(user): Modify the Reconcile function to compare the state specified by
@@ -79,7 +81,7 @@ func (r *NonAdminBackupReconciler) Reconcile(ctx context.Context, req ctrl.Reque
 	veleroBackupSpec, err := GetVeleroBackupSpecFromNonAdminBackup(&nab)
 
 	if veleroBackupSpec == nil {
-		log.Error(err, "unable to fetch VeleroBackupSpec from NonAdminBackup")
+		log.Error(err, "NonAdminBackup CR does not contain valid VeleroBackupSpec")
 		return ctrl.Result{}, nil
 	}
 
@@ -106,10 +108,14 @@ func (r *NonAdminBackupReconciler) Reconcile(ctx context.Context, req ctrl.Reque
 			Spec: *veleroBackupSpec,
 		}
 	} else if err != nil && !errors.IsNotFound(err) {
-		log.Error(err, "unable to fetch VeleroBackup")
+		log.Error(err, "Unable to fetch VeleroBackup")
 		return ctrl.Result{}, err
 	} else {
-		log.Info("Backup already exists", "Name", veleroBackupName)
+		log.Info("Backup already exists, updating NonAdminBackup status", "Name", veleroBackupName)
+		err := UpdateNonAdminBackupFromVeleroBackup(ctx, r.Client, log, &nab, &veleroBackup)
+		if err != nil {
+			return ctrl.Result{}, err
+		}
 		return ctrl.Result{}, nil
 	}
 
@@ -142,5 +148,13 @@ func (r *NonAdminBackupReconciler) Reconcile(ctx context.Context, req ctrl.Reque
 func (r *NonAdminBackupReconciler) SetupWithManager(mgr ctrl.Manager) error {
 	return ctrl.NewControllerManagedBy(mgr).
 		For(&nacv1alpha1.NonAdminBackup{}).
+		Watches(&velerov1api.Backup{}, &VeleroBackupHandler{}).
+		WithEventFilter(CompositePredicate{
+			NonAdminBackupPredicate: NonAdminBackupPredicate{},
+			VeleroBackupPredicate: VeleroBackupPredicate{
+				OadpVeleroNamespace: "openshift-adp",
+			},
+			Context: r.Context,
+		}).
 		Complete(r)
 }

internal/controller/nonadminbackup_predicate.go

@@ -0,0 +1,67 @@
+// velerobackup_predicate.go
+
+package controller
+
+import (
+	"context"
+
+	"github.com/go-logr/logr"
+	nacv1alpha1 "github.com/migtools/oadp-non-admin/api/v1alpha1"
+	"k8s.io/apimachinery/pkg/types"
+	"sigs.k8s.io/controller-runtime/pkg/event"
+	"sigs.k8s.io/controller-runtime/pkg/log"
+)
+
+type NonAdminBackupPredicate struct {
+	Logger logr.Logger
+}
+
+func getNonAdminBackupPredicateLogger(ctx context.Context, name, namespace string) logr.Logger {
+	return log.FromContext(ctx).WithValues("NonAdminBackupPredicate", types.NamespacedName{Name: name, Namespace: namespace})
+}
+
+func (predicate NonAdminBackupPredicate) Create(ctx context.Context, evt event.CreateEvent) bool {
+
+	if _, ok := evt.Object.(*nacv1alpha1.NonAdminBackup); ok {
+		nameSpace := evt.Object.GetNamespace()
+		name := evt.Object.GetName()
+		log := getNonAdminBackupPredicateLogger(ctx, name, nameSpace)
+		log.V(1).Info("Received Create NonAdminBackupPredicate")
+		return true
+	}
+
+	return false
+}
+
+func (predicate NonAdminBackupPredicate) Update(ctx context.Context, evt event.UpdateEvent) bool {
+	if _, ok := evt.ObjectNew.(*nacv1alpha1.NonAdminBackup); ok {
+		nameSpace := evt.ObjectNew.GetNamespace()
+		name := evt.ObjectNew.GetName()
+		log := getNonAdminBackupPredicateLogger(ctx, name, nameSpace)
+		log.V(1).Info("Received Update NonAdminBackupPredicate")
+		return true
+	}
+	return false
+}
+
+func (predicate NonAdminBackupPredicate) Delete(ctx context.Context, evt event.DeleteEvent) bool {
+	if _, ok := evt.Object.(*nacv1alpha1.NonAdminBackup); ok {
+		nameSpace := evt.Object.GetNamespace()
+		name := evt.Object.GetName()
+		log := getNonAdminBackupPredicateLogger(ctx, name, nameSpace)
+		log.V(1).Info("Received Delete NonAdminBackupPredicate")
+		return true
+	}
+	return false
+}
+
+func (predicate NonAdminBackupPredicate) Generic(ctx context.Context, evt event.GenericEvent) bool {
+	if _, ok := evt.Object.(*nacv1alpha1.NonAdminBackup); ok {
+		nameSpace := evt.Object.GetNamespace()
+		name := evt.Object.GetName()
+		log := getNonAdminBackupPredicateLogger(ctx, name, nameSpace)
+		log.V(1).Info("Received Generic NonAdminBackupPredicate")
+		return true
+	}
+	return false
+}