Add cross resource watching on Postgres objects

Author: pcallewaert

internal/controller/postgresuser_controller.go

@@ -14,10 +14,15 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/types"
 	ctrl "sigs.k8s.io/controller-runtime"
+	"sigs.k8s.io/controller-runtime/pkg/builder"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
+	"sigs.k8s.io/controller-runtime/pkg/event"
+	"sigs.k8s.io/controller-runtime/pkg/handler"
 	"sigs.k8s.io/controller-runtime/pkg/log"
 	"sigs.k8s.io/controller-runtime/pkg/manager"
+	"sigs.k8s.io/controller-runtime/pkg/predicate"
+	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 
 	dbv1alpha1 "github.com/movetokube/postgres-operator/api/v1alpha1"
 	"github.com/movetokube/postgres-operator/pkg/config"
@@ -473,9 +478,70 @@ func (r *PostgresUserReconciler) finish(ctx context.Context, cr *dbv1alpha1.Post
 	return ctrl.Result{}, nil
 }
 
+// findPostgresUsersForPostgres returns reconcile requests for all PostgresUsers
+// that reference the given Postgres CR by name within the same namespace.
+// This enables eventual consistency when a Postgres CR is created after PostgresUsers
+// that reference it.
+func (r *PostgresUserReconciler) findPostgresUsersForPostgres(ctx context.Context, obj client.Object) []reconcile.Request {
+	postgres := obj.(*dbv1alpha1.Postgres)
+	logger := log.FromContext(ctx)
+
+	var userList dbv1alpha1.PostgresUserList
+	if err := r.List(ctx, &userList, client.InNamespace(postgres.Namespace)); err != nil {
+		logger.Error(err, "Failed to list PostgresUsers for Postgres CR", "postgres", postgres.Name)
+		return nil
+	}
+
+	var requests []reconcile.Request
+	for _, user := range userList.Items {
+		if user.Spec.Database == postgres.Name {
+			requests = append(requests, reconcile.Request{
+				NamespacedName: types.NamespacedName{
+					Name:      user.Name,
+					Namespace: user.Namespace,
+				},
+			})
+		}
+	}
+
+	if len(requests) > 0 {
+		logger.Info("Enqueuing PostgresUsers for Postgres CR change",
+			"postgres", postgres.Name, "userCount", len(requests))
+	}
+	return requests
+}
+
 // SetupWithManager sets up the controller with the Manager.
+// It watches PostgresUser CRs as the primary resource and also watches Postgres CRs
+// to trigger reconciliation of PostgresUsers when their referenced Postgres CR changes.
+// This ensures eventual consistency when PostgresUsers are created before their
+// referenced Postgres CR exists.
 func (r *PostgresUserReconciler) SetupWithManager(mgr ctrl.Manager) error {
 	return ctrl.NewControllerManagedBy(mgr).
 		For(&dbv1alpha1.PostgresUser{}).
+		Watches(
+			&dbv1alpha1.Postgres{},
+			handler.EnqueueRequestsFromMapFunc(r.findPostgresUsersForPostgres),
+			builder.WithPredicates(predicate.Funcs{
+				CreateFunc: func(e event.CreateEvent) bool {
+					// Trigger when Postgres CR is created and already succeeded
+					pg := e.Object.(*dbv1alpha1.Postgres)
+					return pg.Status.Succeeded
+				},
+				UpdateFunc: func(e event.UpdateEvent) bool {
+					// Trigger when Postgres CR transitions to succeeded state
+					oldPg := e.ObjectOld.(*dbv1alpha1.Postgres)
+					newPg := e.ObjectNew.(*dbv1alpha1.Postgres)
+					return !oldPg.Status.Succeeded && newPg.Status.Succeeded
+				},
+				DeleteFunc: func(e event.DeleteEvent) bool {
+					// Trigger on deletion to allow cleanup of dependent resources
+					return true
+				},
+				GenericFunc: func(e event.GenericEvent) bool {
+					return false
+				},
+			}),
+		).
 		Complete(r)
 }

internal/controller/postgresuser_controller_test.go

@@ -916,4 +916,112 @@ var _ = Describe("PostgresUser Controller", func() {
 			Expect(secret.Name).To(Equal("mysecret3"))
 		})
 	})
+
+	Describe("Cross-resource watching", func() {
+		var (
+			postgresDB    *dbv1alpha1.Postgres
+			postgresUser1 *dbv1alpha1.PostgresUser
+			postgresUser2 *dbv1alpha1.PostgresUser
+		)
+
+		BeforeEach(func() {
+			postgresDB = &dbv1alpha1.Postgres{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      databaseName,
+					Namespace: namespace,
+				},
+				Spec: dbv1alpha1.PostgresSpec{
+					Database: databaseName,
+				},
+				Status: dbv1alpha1.PostgresStatus{
+					Succeeded: true,
+					Roles: dbv1alpha1.PostgresRoles{
+						Owner:  databaseName + "-group",
+						Reader: databaseName + "-reader",
+						Writer: databaseName + "-writer",
+					},
+				},
+			}
+
+			postgresUser1 = &dbv1alpha1.PostgresUser{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      "user-for-db",
+					Namespace: namespace,
+				},
+				Spec: dbv1alpha1.PostgresUserSpec{
+					Database:   databaseName,
+					SecretName: secretName,
+					Role:       roleName,
+					Privileges: "WRITE",
+				},
+			}
+
+			postgresUser2 = &dbv1alpha1.PostgresUser{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      "user-for-other-db",
+					Namespace: namespace,
+				},
+				Spec: dbv1alpha1.PostgresUserSpec{
+					Database:   "other-db",
+					SecretName: secretName,
+					Role:       roleName,
+					Privileges: "READ",
+				},
+			}
+		})
+
+		Context("findPostgresUsersForPostgres mapping function", func() {
+			It("should return reconcile requests for PostgresUsers referencing the Postgres CR", func() {
+				// Create users first (without the Postgres CR)
+				Expect(cl.Create(ctx, postgresUser1)).To(Succeed())
+				Expect(cl.Create(ctx, postgresUser2)).To(Succeed())
+
+				// Call the mapping function
+				requests := rp.findPostgresUsersForPostgres(ctx, postgresDB)
+
+				// Should only return the user that references our database
+				Expect(requests).To(HaveLen(1))
+				Expect(requests[0].Name).To(Equal("user-for-db"))
+				Expect(requests[0].Namespace).To(Equal(namespace))
+			})
+
+			It("should return empty list when no PostgresUsers reference the Postgres CR", func() {
+				// Create a user that references a different database
+				Expect(cl.Create(ctx, postgresUser2)).To(Succeed())
+
+				// Call the mapping function
+				requests := rp.findPostgresUsersForPostgres(ctx, postgresDB)
+
+				// Should return empty list
+				Expect(requests).To(BeEmpty())
+			})
+
+			It("should return multiple requests when multiple PostgresUsers reference the same Postgres CR", func() {
+				// Create two users that reference the same database
+				Expect(cl.Create(ctx, postgresUser1)).To(Succeed())
+
+				anotherUser := &dbv1alpha1.PostgresUser{
+					ObjectMeta: metav1.ObjectMeta{
+						Name:      "another-user-for-db",
+						Namespace: namespace,
+					},
+					Spec: dbv1alpha1.PostgresUserSpec{
+						Database:   databaseName,
+						SecretName: "another-secret",
+						Role:       "another-role",
+						Privileges: "READ",
+					},
+				}
+				Expect(cl.Create(ctx, anotherUser)).To(Succeed())
+
+				// Call the mapping function
+				requests := rp.findPostgresUsersForPostgres(ctx, postgresDB)
+
+				// Should return both users
+				Expect(requests).To(HaveLen(2))
+				names := []string{requests[0].Name, requests[1].Name}
+				Expect(names).To(ContainElements("user-for-db", "another-user-for-db"))
+			})
+		})
+	})
 })