controllers: Refactored Postgres connection setup to utils.

This is expected to be reused for future Postgres resources.

Author: yjwong

controllers/postgresconfig_controller.go

@@ -34,11 +34,10 @@ import (
 )
 
 const (
-	EventTypeMissingSecret          string = "MissingSecret"
-	EventTypeFailedConnectPostgres  string = "FailedConnectPostgres"
-	EventTypeSuccessConnectPostgres string = "SuccessConnectPostgres"
-	EventTypeFailedReconcile        string = "FailedReconcile"
-	EventTypeSuccessfulReconcile    string = "SuccessfulReconcile"
+	EventTypeFailedSetupPostgresConnection string = "FailedSetupPostgresConnection"
+	EventTypeSuccessConnectPostgres        string = "SuccessConnectPostgres"
+	EventTypeFailedReconcile               string = "FailedReconcile"
+	EventTypeSuccessfulReconcile           string = "SuccessfulReconcile"
 )
 
 var (

controllers/postgrespublication_controller.go

@@ -19,13 +19,11 @@ package controllers
 import (
 	"context"
 	"fmt"
-	"net/url"
 
 	"github.com/go-logr/logr"
 	"github.com/jackc/pgx/v4"
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/client-go/tools/record"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
@@ -71,43 +69,19 @@ func (r *PostgresPublicationReconciler) Reconcile(ctx context.Context, req ctrl.
 		return ctrl.Result{}, client.IgnoreNotFound(err)
 	}
 
-	secretNamespacedName := types.NamespacedName{
-		Name:      publication.Spec.PostgresRef.SecretRef.SecretName,
-		Namespace: publication.GetNamespace(),
-	}
-	secretRef := &corev1.Secret{}
-	if err := r.Get(ctx, secretNamespacedName, secretRef); err != nil {
-		r.recorder.Eventf(
-			publication,
-			corev1.EventTypeWarning,
-			EventTypeMissingSecret,
-			"failed to get Secret: %v",
-			err,
-		)
-		return ctrl.Result{Requeue: true}, nil
-	}
-
-	connURL := url.URL{
-		Scheme: "postgres",
-		User: url.UserPassword(
-			string(secretRef.Data["POSTGRES_USER"]),
-			string(secretRef.Data["POSTGRES_PASSWORD"]),
-		),
-		Host: fmt.Sprintf(
-			"%s:%d",
-			publication.Spec.PostgresRef.Host,
-			publication.Spec.PostgresRef.Port,
-		),
-		RawPath: publication.Spec.PostgresRef.Database,
-	}
-	conn, err := pgx.Connect(ctx, connURL.String())
+	conn, err := utils.SetupPostgresConnection(
+		ctx,
+		r,
+		r.recorder,
+		publication.Spec.PostgresRef,
+		publication.ObjectMeta,
+	)
 	if err != nil {
 		r.recorder.Eventf(
 			publication,
 			corev1.EventTypeWarning,
-			EventTypeFailedConnectPostgres,
-			"failed to connect to PostgreSQL: %v",
-			err,
+			EventTypeFailedSetupPostgresConnection,
+			err.Error(),
 		)
 		return ctrl.Result{Requeue: true}, nil
 	}
@@ -149,6 +123,13 @@ func (r *PostgresPublicationReconciler) Reconcile(ctx context.Context, req ctrl.
 		return reconcileResult, nil
 	}
 
+	r.recorder.Event(
+		publication,
+		corev1.EventTypeNormal,
+		EventTypeSuccessfulReconcile,
+		"successfully reconcilled publication",
+	)
+
 	return ctrl.Result{}, nil
 }
 

controllers/utils/errors.go

@@ -0,0 +1,19 @@
+package utils
+
+import "fmt"
+
+type ErrGetSecret struct {
+	Err error
+}
+
+func (e *ErrGetSecret) Error() string {
+	return fmt.Sprintf("failed to get Secret: %s", e.Err.Error())
+}
+
+type ErrFailedConnectPostgres struct {
+	Err error
+}
+
+func (e *ErrFailedConnectPostgres) Error() string {
+	return fmt.Sprintf("failed to connect to PostgreSQL: %s", e.Err.Error())
+}

controllers/utils/utils.go

@@ -2,9 +2,19 @@ package utils
 
 import (
 	"context"
+	"fmt"
+	"net/url"
 
 	"github.com/go-logr/logr"
+	"github.com/jackc/pgx/v4"
+	corev1 "k8s.io/api/core/v1"
+	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"
+
+	postgresv1alpha1 "github.com/glints-dev/postgres-config-operator/api/v1alpha1"
 )
 
 // contextKey represents a value that will be used as a key in Go's context API.
@@ -14,6 +24,39 @@ const (
 	contextKeyRequestLogger contextKey = "request-logger"
 )
 
+func SetupPostgresConnection(
+	ctx context.Context,
+	r client.Reader,
+	recorder record.EventRecorder,
+	ref postgresv1alpha1.PostgresRef,
+	obj metav1.ObjectMeta,
+) (*pgx.Conn, error) {
+	secretNamespacedName := types.NamespacedName{
+		Name:      ref.SecretRef.SecretName,
+		Namespace: obj.GetNamespace(),
+	}
+	secretRef := &corev1.Secret{}
+	if err := r.Get(ctx, secretNamespacedName, secretRef); err != nil {
+		return nil, &ErrGetSecret{Err: err}
+	}
+
+	connURL := url.URL{
+		Scheme: "postgres",
+		User: url.UserPassword(
+			string(secretRef.Data["POSTGRES_USER"]),
+			string(secretRef.Data["POSTGRES_PASSWORD"]),
+		),
+		Host:    fmt.Sprintf("%s:%d", ref.Host, ref.Port),
+		RawPath: ref.Database,
+	}
+	conn, err := pgx.Connect(ctx, connURL.String())
+	if err != nil {
+		return nil, &ErrFailedConnectPostgres{Err: err}
+	}
+
+	return conn, nil
+}
+
 // WithRequestLogger returns a context that has a request-scoped logger attached
 // to it.
 func WithRequestLogger(