Add nginx config hash; remove API group cache

Compute a SHA-256 of the generated nginx.conf and annotate the reverse-proxy Deployment with typesense-operator/nginx-config-hash so changes to ingress directives cause a rollout. Removed the previous configMapUpdated/restart-timestamp logic. Updated getNodes call to pass the resizeOp flag. Removed apiGroupsCache, its mutex and caching logic from IsApiGroupDeployed so discovery is queried directly. Added tests to verify the nginx config hash changes when ingress directives change and remains stable on no-op reconciles. Cleaned up related imports and unused fields.

Author: Firanzo

internal/controller/typesensecluster_configmap.go

@@ -119,7 +119,7 @@ func (r *TypesenseClusterReconciler) updateConfigMap(ctx context.Context, ts *ts
 		}
 	}
 
-	nodes, err := r.getNodes(ctx, ts, *replicas, false)
+	nodes, err := r.getNodes(ctx, ts, *replicas, resizeOp)
 	if err != nil {
 		return false, err
 	}

internal/controller/typesensecluster_controller.go

@@ -22,7 +22,6 @@ import (
 	"fmt"
 	"net/http"
 	"strings"
-	"sync"
 	"time"
 
 	"github.com/go-logr/logr"
@@ -64,9 +63,7 @@ type TypesenseClusterReconciler struct {
 	InCluster       bool
 	HttpClient      *http.Client
 
-	apiGroupsCache map[string]bool
-	apiGroupsMutex sync.RWMutex
-	serverVersion  string
+	serverVersion string
 }
 
 type TypesenseClusterReconciliationPhase struct {

internal/controller/typesensecluster_controller_test.go

@@ -33,6 +33,7 @@ import (
 	"k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/rest"
 	"k8s.io/client-go/tools/record"
+	"k8s.io/utils/ptr"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 
@@ -238,6 +239,58 @@ var _ = Describe("TypesenseCluster Controller", func() {
 			}, resolverSvc)).To(Succeed())
 			Expect(resolverSvc.Spec.Ports).To(HaveLen(2))
 		})
+
+		It("should update the reverse proxy deployment when ingress configuration changes", func(ctx context.Context) {
+			tsResource := &tsv1alpha1.TypesenseCluster{}
+			Expect(k8sClient.Get(ctx, typeNamespacedName, tsResource)).To(Succeed())
+
+			// Enable Ingress with initial directives
+			tsResource.Spec.Ingress = &tsv1alpha1.IngressSpec{
+				Host:             "ts.example.com",
+				HttpDirectives:   ptr.To("client_max_body_size 10m;"),
+				IngressClassName: "nginx",
+			}
+			Expect(k8sClient.Update(ctx, tsResource)).To(Succeed())
+
+			controllerReconciler := newControllerReconciler()
+			runReconcile(ctx, controllerReconciler, reconcile.Request{NamespacedName: typeNamespacedName})
+
+			deploy := &appsv1.Deployment{}
+			Expect(k8sClient.Get(ctx, types.NamespacedName{
+				Name:      fmt.Sprintf(ClusterReverseProxy, resourceName),
+				Namespace: defaultNamespace,
+			}, deploy)).To(Succeed())
+
+			initialHash := deploy.Spec.Template.Annotations[NginxConfigHashAnnotationKey]
+			Expect(initialHash).ToNot(BeEmpty())
+
+			// Update Ingress directives
+			Expect(k8sClient.Get(ctx, typeNamespacedName, tsResource)).To(Succeed())
+			tsResource.Spec.Ingress.HttpDirectives = ptr.To("client_max_body_size 20m;")
+			Expect(k8sClient.Update(ctx, tsResource)).To(Succeed())
+
+			runReconcile(ctx, controllerReconciler, reconcile.Request{NamespacedName: typeNamespacedName})
+
+			Expect(k8sClient.Get(ctx, types.NamespacedName{
+				Name:      fmt.Sprintf(ClusterReverseProxy, resourceName),
+				Namespace: defaultNamespace,
+			}, deploy)).To(Succeed())
+
+			newHash := deploy.Spec.Template.Annotations[NginxConfigHashAnnotationKey]
+			Expect(newHash).ToNot(BeEmpty())
+			Expect(newHash).ToNot(Equal(initialHash))
+
+			// Re-reconcile without changes and check that the hash remains the same
+			runReconcile(ctx, controllerReconciler, reconcile.Request{NamespacedName: typeNamespacedName})
+
+			Expect(k8sClient.Get(ctx, types.NamespacedName{
+				Name:      fmt.Sprintf(ClusterReverseProxy, resourceName),
+				Namespace: defaultNamespace,
+			}, deploy)).To(Succeed())
+
+			finalHash := deploy.Spec.Template.Annotations[NginxConfigHashAnnotationKey]
+			Expect(finalHash).To(Equal(newHash))
+		})
 	})
 
 	Context("When reconciling a resource in a custom namespace", func() {

internal/controller/typesensecluster_helpers.go

@@ -52,38 +52,16 @@ func (r *TypesenseClusterReconciler) IsFeatureSupported(minimum string) (bool, s
 }
 
 func (r *TypesenseClusterReconciler) IsApiGroupDeployed(apiGroup string) (bool, error) {
-	r.apiGroupsMutex.RLock()
-	if supported, exists := r.apiGroupsCache[apiGroup]; exists {
-		r.apiGroupsMutex.RUnlock()
-		if supported {
-			return true, nil
-		}
-	} else {
-		r.apiGroupsMutex.RUnlock()
-	}
-
 	apiGroupList, err := r.DiscoveryClient.ServerGroups()
 	if err != nil {
 		return false, err
 	}
 
 	for _, ag := range apiGroupList.Groups {
 		if ag.Name == apiGroup {
-			r.apiGroupsMutex.Lock()
-			if r.apiGroupsCache == nil {
-				r.apiGroupsCache = make(map[string]bool)
-			}
-			r.apiGroupsCache[apiGroup] = true
-			r.apiGroupsMutex.Unlock()
 			return true, nil
 		}
 	}
 
-	r.apiGroupsMutex.Lock()
-	if r.apiGroupsCache == nil {
-		r.apiGroupsCache = make(map[string]bool)
-	}
-	r.apiGroupsCache[apiGroup] = false
-	r.apiGroupsMutex.Unlock()
 	return false, nil
 }

internal/controller/typesensecluster_ingress.go

@@ -3,12 +3,12 @@ package controller
 import (
 	"bytes"
 	"context"
+	"crypto/sha256"
 	"fmt"
 	"maps"
 	"strconv"
 	"strings"
 	"text/template"
-	"time"
 
 	tsv1alpha1 "github.com/akyriako/typesense-operator/api/v1alpha1"
 	appsv1 "k8s.io/api/apps/v1"
@@ -76,6 +76,8 @@ http {
 const (
 	clusterIssuerAnnotationKey = "cert-manager.io/cluster-issuer"
 	nginxConfKey               = "nginx.conf"
+	// NginxConfigHashAnnotationKey is the annotation key for the nginx config hash.
+	NginxConfigHashAnnotationKey = "typesense-operator/nginx-config-hash"
 )
 
 //nolint:gocyclo // ReconcileIngress coordinates multiple child resources
@@ -158,7 +160,6 @@ func (r *TypesenseClusterReconciler) ReconcileIngress(ctx context.Context, ts *t
 		}
 	}
 
-	configMapUpdated := false
 	if !configMapExists {
 		r.logger.V(debugLevel).Info("creating ingress config map", "configmap", configMapObjectKey.Name)
 
@@ -180,8 +181,6 @@ func (r *TypesenseClusterReconciler) ReconcileIngress(ctx context.Context, ts *t
 			if err != nil {
 				return err
 			}
-
-			configMapUpdated = true
 		}
 	}
 
@@ -207,11 +206,14 @@ func (r *TypesenseClusterReconciler) ReconcileIngress(ctx context.Context, ts *t
 		replicas = *ts.Spec.Ingress.Replicas
 	}
 
-	podAnnotations := make(map[string]string)
-	if configMapUpdated {
-		podAnnotations["kubectl.kubernetes.io/restartedAt"] = time.Now().Format(time.RFC3339)
+	nginxConf, err := r.getIngressNginxConf(ts)
+	if err != nil {
+		return err
 	}
 
+	podAnnotations := make(map[string]string)
+	podAnnotations[NginxConfigHashAnnotationKey] = fmt.Sprintf("%x", sha256.Sum256([]byte(nginxConf)))
+
 	desiredDeployment := &appsv1.Deployment{
 		TypeMeta: metav1.TypeMeta{
 			APIVersion: appsv1.SchemeGroupVersion.String(),