From 3c79dc6f42176875a7003922d739f7424d6ca36d Mon Sep 17 00:00:00 2001 From: Adi Muraru Date: Wed, 18 Nov 2026 17:57:49 +0100 Subject: [PATCH 1/4] feat(operator): expose health and readiness probes Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- Makefile | 2 +- README.md | 20 +- .../templates/operator.yaml | 14 ++ config/manager/manager.yaml | 14 ++ main.go | 73 ++++++- main_test.go | 204 ++++++++++++++++++ test/manifests/contracts_test.go | 67 ++++++ 7 files changed, 381 insertions(+), 13 deletions(-) create mode 100644 main_test.go diff --git a/Makefile b/Makefile index e3a657fb..710b9f80 100644 --- a/Makefile +++ b/Makefile @@ -183,7 +183,7 @@ setup-envtest: $(LOCALBIN) test-envtest: setup-envtest @assets="$$("$(SETUP_ENVTEST)" use "$(ENVTEST_K8S_VERSION)" --bin-dir "$(LOCALBIN)/k8s" -p path)" && \ test -x "$$assets/kube-apiserver" && test -x "$$assets/etcd" && test -x "$$assets/kubectl" && \ - KUBEBUILDER_ASSETS="$$assets" go test -tags=envtest ./controllers -run '^TestEnvtest' -count=1 -v + KUBEBUILDER_ASSETS="$$assets" go test -tags=envtest . ./controllers -run '^(TestEnvtest|TestOperatorHealth)' -count=1 -v test-e2e: test-e2e-remote diff --git a/README.md b/README.md index 879df04c..454df5c2 100644 --- a/README.md +++ b/README.md @@ -144,6 +144,14 @@ NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE zookeeper-operator 1 1 1 1 12m ``` +The operator serves `/healthz` (process liveness) and `/readyz` on +`--health-probe-bind-address` (default `:8081`), separately from metrics. +Helm and Kustomize deployments probe this container port without exposing a +Service. Readiness requires manager cache initialization and becomes false on +shutdown; standby managers can be ready without holding the leader lease. +Neither probe reports ZooKeeper ensemble readiness or requires ZooKeeper to be +available. Use each `ZookeeperCluster`'s status to check its ensemble. + ### Deploy a sample Zookeeper cluster #### Manual deployment @@ -486,17 +494,17 @@ The list of available commands are ### API-server integration tests `make test` runs the fast unit suite without Kubernetes binaries. -Run `make test-envtest` for the opt-in controller API-server tests. This target +Run `make test-envtest` for the opt-in manager and controller API-server tests. This target installs the `ENVTEST_TOOL_VERSION` pinned in the Makefile and downloads its `ENVTEST_K8S_VERSION` assets into `bin/k8s`. Missing or unusable assets fail the target instead of skipping tests. The same target gates CI and releases. -The tagged suite verifies status-subresource isolation, stale-update conflicts, -and deletion finalizers using the repository CRD and isolated namespaces. -It does not run the operator, a StatefulSet controller, garbage collection, or -a storage provisioner; full reconciliation and storage behavior still require -the live kind e2e suite. +The tagged suite verifies operator probe startup/shutdown behavior, +status-subresource isolation, stale-update conflicts, and deletion finalizers +using the repository CRD and isolated namespaces. It runs the manager in-process +without a StatefulSet controller, garbage collection, or a storage provisioner; +full reconciliation and storage behavior still require the live kind e2e suite. ### Update dependencies diff --git a/charts/zookeeper-operator/templates/operator.yaml b/charts/zookeeper-operator/templates/operator.yaml index 8de09aca..64815335 100644 --- a/charts/zookeeper-operator/templates/operator.yaml +++ b/charts/zookeeper-operator/templates/operator.yaml @@ -37,6 +37,20 @@ spec: ports: - containerPort: {{ int .Values.metricsPort }} name: metrics + - containerPort: 8081 + name: health + livenessProbe: + httpGet: + path: /healthz + port: health + periodSeconds: 10 + failureThreshold: 3 + readinessProbe: + httpGet: + path: /readyz + port: health + periodSeconds: 5 + failureThreshold: 3 command: - zookeeper-operator args: diff --git a/config/manager/manager.yaml b/config/manager/manager.yaml index 989e3ca9..72a46933 100644 --- a/config/manager/manager.yaml +++ b/config/manager/manager.yaml @@ -19,6 +19,20 @@ spec: ports: - containerPort: 60000 name: metrics + - containerPort: 8081 + name: health + livenessProbe: + httpGet: + path: /healthz + port: health + periodSeconds: 10 + failureThreshold: 3 + readinessProbe: + httpGet: + path: /readyz + port: health + periodSeconds: 5 + failureThreshold: 3 command: - zookeeper-operator imagePullPolicy: Always diff --git a/main.go b/main.go index 2331a332..f91641bf 100644 --- a/main.go +++ b/main.go @@ -11,18 +11,23 @@ package main import ( + "context" "crypto/md5" "flag" "fmt" "io" + "net/http" "os" "runtime" "strings" + "sync/atomic" zkConfig "github.com/pravega/zookeeper-operator/pkg/controller/config" "github.com/pravega/zookeeper-operator/pkg/version" zkClient "github.com/pravega/zookeeper-operator/pkg/zk" "github.com/sirupsen/logrus" + appsv1 "k8s.io/api/apps/v1" + corev1 "k8s.io/api/core/v1" apimachineryruntime "k8s.io/apimachinery/pkg/runtime" utilruntime "k8s.io/apimachinery/pkg/util/runtime" clientgoscheme "k8s.io/client-go/kubernetes/scheme" @@ -30,7 +35,10 @@ import ( _ "k8s.io/client-go/plugin/pkg/client/auth/oidc" ctrl "sigs.k8s.io/controller-runtime" "sigs.k8s.io/controller-runtime/pkg/cache" + "sigs.k8s.io/controller-runtime/pkg/client" + "sigs.k8s.io/controller-runtime/pkg/healthz" "sigs.k8s.io/controller-runtime/pkg/log/zap" + "sigs.k8s.io/controller-runtime/pkg/manager" "sigs.k8s.io/controller-runtime/pkg/metrics/server" api "github.com/pravega/zookeeper-operator/api/v1beta1" @@ -61,8 +69,10 @@ func printVersion() { func main() { var metricsAddr string + var healthProbeAddr string var enableLeaderElection bool flag.StringVar(&metricsAddr, "metrics-bind-address", "127.0.0.1:6000", "The address the metric endpoint binds to.") + flag.StringVar(&healthProbeAddr, "health-probe-bind-address", ":8081", "The address the health probe endpoint binds to.") flag.BoolVar(&enableLeaderElection, "enable-leader-election", true, "Enable leader election for controller manager. Enabling this will ensure there is only one active controller manager.") opts := zap.Options{} @@ -113,11 +123,12 @@ func main() { } mgr, err := ctrl.NewManager(ctrl.GetConfigOrDie(), ctrl.Options{ - Scheme: scheme, - Cache: cacheOpts, - Metrics: server.Options{BindAddress: metricsAddr}, - LeaderElection: enableLeaderElection, - LeaderElectionID: leaderElectionID, + Scheme: scheme, + Cache: cacheOpts, + Metrics: server.Options{BindAddress: metricsAddr}, + HealthProbeBindAddress: healthProbeAddr, + LeaderElection: enableLeaderElection, + LeaderElectionID: leaderElectionID, }) if err != nil { log.Error(err, "unable to start manager") @@ -135,13 +146,63 @@ func main() { } // +kubebuilder:scaffold:builder + ctx := ctrl.SetupSignalHandler() + if err := configureHealthChecks(ctx, mgr); err != nil { + log.Error(err, "unable to configure health probes") + os.Exit(1) + } + log.Info("starting manager") - if err := mgr.Start(ctrl.SetupSignalHandler()); err != nil { + if err := mgr.Start(ctx); err != nil { log.Error(err, "problem running manager") os.Exit(1) } } +func configureHealthChecks(ctx context.Context, mgr manager.Manager) error { + // Register existing watches before startup so initial cache sync cannot be empty. + for _, object := range []client.Object{ + &api.ZookeeperCluster{}, &appsv1.StatefulSet{}, &corev1.Service{}, &corev1.Pod{}, + } { + if _, err := mgr.GetCache().GetInformer(ctx, object, cache.BlockUntilSynced(false)); err != nil { + return fmt.Errorf("initialize probe cache: %w", err) + } + } + if err := mgr.AddHealthzCheck("ping", healthz.Ping); err != nil { + return err + } + readiness := &managerReadiness{} + if err := mgr.AddReadyzCheck("manager", func(_ *http.Request) error { + if err := ctx.Err(); err != nil { + return err + } + if !readiness.ready.Load() { + return fmt.Errorf("manager cache is not initialized") + } + return nil + }); err != nil { + return err + } + return mgr.Add(readiness) +} + +type managerReadiness struct { + ready atomic.Bool +} + +func (r *managerReadiness) Start(ctx context.Context) error { + // The manager starts non-leader runnables only after its caches sync. + r.ready.Store(true) + <-ctx.Done() + r.ready.Store(false) + return nil +} + +func (*managerReadiness) NeedLeaderElection() bool { + // Standbys must become ready so a rolling update can replace the old leader. + return false +} + // getWatchNamespace returns the Namespace the operator should be watching for changes func getWatchNamespace() (string, error) { // WatchNamespaceEnvVar is the constant for env variable WATCH_NAMESPACE diff --git a/main_test.go b/main_test.go new file mode 100644 index 00000000..da4631c6 --- /dev/null +++ b/main_test.go @@ -0,0 +1,204 @@ +//go:build envtest + +// Copyright 2026 Adobe. All rights reserved. +// Licensed under the Apache License, Version 2.0. + +package main + +import ( + "context" + "errors" + "net" + "net/http" + "path/filepath" + "strings" + "sync" + "testing" + "time" + + api "github.com/pravega/zookeeper-operator/api/v1beta1" + "github.com/pravega/zookeeper-operator/controllers" + zkClient "github.com/pravega/zookeeper-operator/pkg/zk" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + ctrl "sigs.k8s.io/controller-runtime" + "sigs.k8s.io/controller-runtime/pkg/client" + "sigs.k8s.io/controller-runtime/pkg/envtest" + "sigs.k8s.io/controller-runtime/pkg/manager" + "sigs.k8s.io/controller-runtime/pkg/metrics/server" +) + +func TestOperatorHealthLifecycle(t *testing.T) { + environment := &envtest.Environment{ + CRDDirectoryPaths: []string{filepath.Join("config", "crd", "bases")}, + ErrorIfCRDPathMissing: true, + } + cfg, err := environment.Start() + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { + if err := environment.Stop(); err != nil { + t.Error(err) + } + }) + listener, err := net.Listen("tcp", "127.0.0.1:0") + if err != nil { + t.Fatal(err) + } + address := listener.Addr().String() + if err := listener.Close(); err != nil { + t.Fatal(err) + } + initialize := make(chan struct{}) + var initializeOnce sync.Once + finishInitialization := func() { initializeOnce.Do(func() { close(initialize) }) } + cacheStarting := make(chan struct{}) + var startingOnce sync.Once + cfg.Wrap(func(transport http.RoundTripper) http.RoundTripper { + return roundTripperFunc(func(request *http.Request) (*http.Response, error) { + if request.Method == http.MethodGet && strings.HasSuffix(request.URL.Path, "/zookeeperclusters") { + startingOnce.Do(func() { close(cacheStarting) }) + select { + case <-initialize: + case <-request.Context().Done(): + return nil, request.Context().Err() + } + } + return transport.RoundTrip(request) + }) + }) + mgr, err := ctrl.NewManager(cfg, ctrl.Options{ + Scheme: scheme, + Metrics: server.Options{BindAddress: "0"}, + HealthProbeBindAddress: address, + }) + if err != nil { + t.Fatal(err) + } + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + if err := configureHealthChecks(ctx, mgr); err != nil { + t.Fatal(err) + } + zkDown := &unavailableZooKeeper{attempted: make(chan struct{})} + if err := (&controllers.ZookeeperClusterReconciler{ + Client: mgr.GetClient(), Scheme: scheme, Log: ctrl.Log, ZkClient: zkDown, + }).SetupWithManager(mgr); err != nil { + t.Fatal(err) + } + stopping, finishShutdown := make(chan struct{}), make(chan struct{}) + var finishOnce sync.Once + releaseShutdown := func() { finishOnce.Do(func() { close(finishShutdown) }) } + defer releaseShutdown() + if err := mgr.Add(manager.RunnableFunc(func(ctx context.Context) error { + <-ctx.Done() + close(stopping) + <-finishShutdown + return nil + })); err != nil { + t.Fatal(err) + } + done := make(chan error, 1) + go func() { done <- mgr.Start(ctx) }() + defer func() { + finishInitialization() + cancel() + releaseShutdown() + select { + case err := <-done: + if err != nil { + t.Error(err) + } + case <-time.After(15 * time.Second): + t.Error("manager did not shut down") + } + }() + awaitSignal(t, cacheStarting, "cache initialization") + baseURL := "http://" + address + awaitProbe(t, baseURL+"/healthz", http.StatusOK) + t.Run("not ready during cache initialization", func(t *testing.T) { + awaitProbe(t, baseURL+"/readyz", http.StatusInternalServerError) + }) + + c, err := client.New(cfg, client.Options{Scheme: scheme}) + if err != nil { + t.Fatal(err) + } + cluster := &api.ZookeeperCluster{ + ObjectMeta: metav1.ObjectMeta{Name: "unavailable", Namespace: "default"}, + Spec: api.ZookeeperClusterSpec{Replicas: 2}, + } + cluster.WithDefaults() + if err := c.Create(ctx, cluster); err != nil { + t.Fatal(err) + } + // No StatefulSet controller or ZooKeeper server runs in envtest. + // A mismatched replica count forces a real reconciliation to contact ZooKeeper. + sts := zkClient.MakeStatefulSet(cluster) + *sts.Spec.Replicas = 1 + if err := c.Create(ctx, sts); err != nil { + t.Fatal(err) + } + finishInitialization() + awaitProbe(t, baseURL+"/readyz", http.StatusOK) + awaitSignal(t, zkDown.attempted, "failed ZooKeeper connection during reconciliation") + awaitProbe(t, baseURL+"/healthz", http.StatusOK) + awaitProbe(t, baseURL+"/readyz", http.StatusOK) + + cancel() + awaitSignal(t, stopping, "controller shutdown") + t.Run("not ready while controller work drains", func(t *testing.T) { + awaitProbe(t, baseURL+"/readyz", http.StatusInternalServerError) + }) + // HTTP probes remain available while controller work drains. + awaitProbe(t, baseURL+"/healthz", http.StatusOK) +} + +type roundTripperFunc func(*http.Request) (*http.Response, error) + +func (f roundTripperFunc) RoundTrip(request *http.Request) (*http.Response, error) { + return f(request) +} + +type unavailableZooKeeper struct { + zkClient.ZookeeperClient + attempted chan struct{} + once sync.Once +} + +func (z *unavailableZooKeeper) Connect(string) error { + z.once.Do(func() { close(z.attempted) }) + return errors.New("ZooKeeper is unavailable") +} + +func awaitSignal(t *testing.T, signal <-chan struct{}, what string) { + t.Helper() + select { + case <-signal: + case <-time.After(15 * time.Second): + t.Fatalf("timed out waiting for %s", what) + } +} + +func awaitProbe(t *testing.T, url string, want int) { + t.Helper() + httpClient := &http.Client{Timeout: time.Second} + deadline := time.Now().Add(10 * time.Second) + var status int + var err error + for time.Now().Before(deadline) { + var response *http.Response + response, err = httpClient.Get(url) + if err == nil { + status = response.StatusCode + if err := response.Body.Close(); err != nil { + t.Fatal(err) + } + if status == want { + return + } + } + time.Sleep(10 * time.Millisecond) + } + t.Fatalf("%s: status=%d err=%v, want %d", url, status, err, want) +} diff --git a/test/manifests/contracts_test.go b/test/manifests/contracts_test.go index e93c6120..b910a306 100644 --- a/test/manifests/contracts_test.go +++ b/test/manifests/contracts_test.go @@ -215,6 +215,73 @@ func TestEmptySecurityContextPreservesDefaults(t *testing.T) { } } +func TestOperatorHealthProbes(t *testing.T) { + for _, test := range []struct { + name string + command string + args []string + }{ + {"helm", "helm", []string{"template", "zookeeper-operator", "charts/zookeeper-operator", "--kube-version", "1.34.3"}}, + {"kustomize", "bin/kustomize", []string{"build", "config/default"}}, + {"e2e", "bin/kustomize", []string{"build", "config/e2e"}}, + } { + t.Run(test.name, func(t *testing.T) { + var operator *corev1.Container + for _, object := range render(t, test.command, test.args...) { + switch object.GetKind() { + case "Service": + var service corev1.Service + if err := runtime.DefaultUnstructuredConverter.FromUnstructured(object.Object, &service); err != nil { + t.Fatal(err) + } + for _, port := range service.Spec.Ports { + if port.Port == 8081 || port.TargetPort.IntVal == 8081 || port.TargetPort.StrVal == "health" { + t.Error("operator probes must not have a public Service") + } + } + case "Deployment": + var deployment appsv1.Deployment + if err := runtime.DefaultUnstructuredConverter.FromUnstructured(object.Object, &deployment); err != nil { + t.Fatal(err) + } + for _, container := range deployment.Spec.Template.Spec.Containers { + if container.Name == "zookeeper-operator" { + operator = &container + } + } + } + } + if operator == nil { + t.Fatal("operator container not found") + } + for _, probe := range []struct { + name string + probe *corev1.Probe + path string + period int32 + }{ + {"liveness", operator.LivenessProbe, "/healthz", 10}, + {"readiness", operator.ReadinessProbe, "/readyz", 5}, + } { + if probe.probe == nil || probe.probe.HTTPGet == nil { + t.Errorf("%s HTTP probe missing", probe.name) + continue + } + get := probe.probe.HTTPGet + if get.Path != probe.path || get.Port.StrVal != "health" || + probe.probe.PeriodSeconds != probe.period || probe.probe.FailureThreshold != 3 { + t.Errorf("%s probe has wrong route, port or timing: %+v", probe.name, probe.probe) + } + } + if !slices.ContainsFunc(operator.Ports, func(port corev1.ContainerPort) bool { + return port.Name == "health" && port.ContainerPort == 8081 + }) { + t.Error("named health container port 8081 missing") + } + }) + } +} + func renderOperator(t *testing.T, values string) appsv1.Deployment { t.Helper() valuesPath := filepath.Join(t.TempDir(), "values.yaml") From f7c8b89080382fd339267c687afe315800b40b47 Mon Sep 17 00:00:00 2001 From: Adi Muraru Date: Wed, 18 Nov 2026 18:02:32 +0100 Subject: [PATCH 2/4] test: select envtest coverage by build tag Remove test-name filtering so newly added tagged tests run automatically. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- Makefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Makefile b/Makefile index 710b9f80..8ed8378b 100644 --- a/Makefile +++ b/Makefile @@ -183,7 +183,7 @@ setup-envtest: $(LOCALBIN) test-envtest: setup-envtest @assets="$$("$(SETUP_ENVTEST)" use "$(ENVTEST_K8S_VERSION)" --bin-dir "$(LOCALBIN)/k8s" -p path)" && \ test -x "$$assets/kube-apiserver" && test -x "$$assets/etcd" && test -x "$$assets/kubectl" && \ - KUBEBUILDER_ASSETS="$$assets" go test -tags=envtest . ./controllers -run '^(TestEnvtest|TestOperatorHealth)' -count=1 -v + KUBEBUILDER_ASSETS="$$assets" go test -tags=envtest . ./controllers -count=1 -v test-e2e: test-e2e-remote From a51ab0da760fbd4d59d815fc372541de85dd35b2 Mon Sep 17 00:00:00 2001 From: Adi Muraru Date: Wed, 18 Nov 2026 18:09:31 +0100 Subject: [PATCH 3/4] test(operator): focus health coverage on empty-cluster lifecycle Remove ZooKeeper outage mocks and scaling fixtures; retain real cache startup, zero-ensemble readiness, and draining shutdown regressions. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- main_test.go | 51 ++++++++------------------------------------------- 1 file changed, 8 insertions(+), 43 deletions(-) diff --git a/main_test.go b/main_test.go index da4631c6..11ba6960 100644 --- a/main_test.go +++ b/main_test.go @@ -7,7 +7,6 @@ package main import ( "context" - "errors" "net" "net/http" "path/filepath" @@ -16,12 +15,9 @@ import ( "testing" "time" - api "github.com/pravega/zookeeper-operator/api/v1beta1" "github.com/pravega/zookeeper-operator/controllers" zkClient "github.com/pravega/zookeeper-operator/pkg/zk" - metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" ctrl "sigs.k8s.io/controller-runtime" - "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/envtest" "sigs.k8s.io/controller-runtime/pkg/manager" "sigs.k8s.io/controller-runtime/pkg/metrics/server" @@ -80,9 +76,9 @@ func TestOperatorHealthLifecycle(t *testing.T) { if err := configureHealthChecks(ctx, mgr); err != nil { t.Fatal(err) } - zkDown := &unavailableZooKeeper{attempted: make(chan struct{})} if err := (&controllers.ZookeeperClusterReconciler{ - Client: mgr.GetClient(), Scheme: scheme, Log: ctrl.Log, ZkClient: zkDown, + Client: mgr.GetClient(), Scheme: scheme, Log: ctrl.Log, + ZkClient: new(zkClient.DefaultZookeeperClient), }).SetupWithManager(mgr); err != nil { t.Fatal(err) } @@ -120,37 +116,17 @@ func TestOperatorHealthLifecycle(t *testing.T) { awaitProbe(t, baseURL+"/readyz", http.StatusInternalServerError) }) - c, err := client.New(cfg, client.Options{Scheme: scheme}) - if err != nil { - t.Fatal(err) - } - cluster := &api.ZookeeperCluster{ - ObjectMeta: metav1.ObjectMeta{Name: "unavailable", Namespace: "default"}, - Spec: api.ZookeeperClusterSpec{Replicas: 2}, - } - cluster.WithDefaults() - if err := c.Create(ctx, cluster); err != nil { - t.Fatal(err) - } - // No StatefulSet controller or ZooKeeper server runs in envtest. - // A mismatched replica count forces a real reconciliation to contact ZooKeeper. - sts := zkClient.MakeStatefulSet(cluster) - *sts.Spec.Replicas = 1 - if err := c.Create(ctx, sts); err != nil { - t.Fatal(err) - } finishInitialization() - awaitProbe(t, baseURL+"/readyz", http.StatusOK) - awaitSignal(t, zkDown.attempted, "failed ZooKeeper connection during reconciliation") - awaitProbe(t, baseURL+"/healthz", http.StatusOK) - awaitProbe(t, baseURL+"/readyz", http.StatusOK) + t.Run("ready without ensembles", func(t *testing.T) { + awaitProbe(t, baseURL+"/readyz", http.StatusOK) + }) cancel() - awaitSignal(t, stopping, "controller shutdown") - t.Run("not ready while controller work drains", func(t *testing.T) { + awaitSignal(t, stopping, "manager shutdown") + t.Run("not ready while manager work drains", func(t *testing.T) { awaitProbe(t, baseURL+"/readyz", http.StatusInternalServerError) }) - // HTTP probes remain available while controller work drains. + // HTTP probes remain available while manager work drains. awaitProbe(t, baseURL+"/healthz", http.StatusOK) } @@ -160,17 +136,6 @@ func (f roundTripperFunc) RoundTrip(request *http.Request) (*http.Response, erro return f(request) } -type unavailableZooKeeper struct { - zkClient.ZookeeperClient - attempted chan struct{} - once sync.Once -} - -func (z *unavailableZooKeeper) Connect(string) error { - z.once.Do(func() { close(z.attempted) }) - return errors.New("ZooKeeper is unavailable") -} - func awaitSignal(t *testing.T, signal <-chan struct{}, what string) { t.Helper() select { From 44ca6ba0c0e032339ddbb95628e03b50ba26019a Mon Sep 17 00:00:00 2001 From: Adi Muraru Date: Wed, 18 Nov 2026 18:19:59 +0100 Subject: [PATCH 4/4] refactor(controller): colocate watches and cache initialization Derive controller watches and eager informer setup from the same primary and owned resource declarations. Keep health checks free of resource-type knowledge. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- controllers/zookeepercluster_controller.go | 19 ++++++++++++++----- main.go | 11 ----------- 2 files changed, 14 insertions(+), 16 deletions(-) diff --git a/controllers/zookeepercluster_controller.go b/controllers/zookeepercluster_controller.go index 9a70f1c9..6377b9c7 100644 --- a/controllers/zookeepercluster_controller.go +++ b/controllers/zookeepercluster_controller.go @@ -35,6 +35,7 @@ import ( "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/types" ctrl "sigs.k8s.io/controller-runtime" + "sigs.k8s.io/controller-runtime/pkg/cache" "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil" "sigs.k8s.io/controller-runtime/pkg/event" @@ -837,11 +838,19 @@ func (r *ZookeeperClusterReconciler) SetupWithManager(mgr ctrl.Manager) error { if r.APIReader == nil { r.APIReader = mgr.GetAPIReader() } - return ctrl.NewControllerManagedBy(mgr). - For(&zookeeperv1beta1.ZookeeperCluster{}). - Owns(&appsv1.StatefulSet{}). - Owns(&corev1.Service{}). - Owns(&corev1.Pod{}). + primary := &zookeeperv1beta1.ZookeeperCluster{} + owned := []client.Object{&appsv1.StatefulSet{}, &corev1.Service{}, &corev1.Pod{}} + controller := ctrl.NewControllerManagedBy(mgr).For(primary) + for _, object := range owned { + controller.Owns(object) + } + // Initialize the same watches eagerly so manager startup waits for their caches. + for _, object := range append([]client.Object{primary}, owned...) { + if _, err := mgr.GetCache().GetInformer(context.TODO(), object, cache.BlockUntilSynced(false)); err != nil { + return fmt.Errorf("initialize cache for %T: %w", object, err) + } + } + return controller. WithEventFilter(reconcileEventPredicate()). Complete(r) } diff --git a/main.go b/main.go index f91641bf..c831adb3 100644 --- a/main.go +++ b/main.go @@ -26,8 +26,6 @@ import ( "github.com/pravega/zookeeper-operator/pkg/version" zkClient "github.com/pravega/zookeeper-operator/pkg/zk" "github.com/sirupsen/logrus" - appsv1 "k8s.io/api/apps/v1" - corev1 "k8s.io/api/core/v1" apimachineryruntime "k8s.io/apimachinery/pkg/runtime" utilruntime "k8s.io/apimachinery/pkg/util/runtime" clientgoscheme "k8s.io/client-go/kubernetes/scheme" @@ -35,7 +33,6 @@ import ( _ "k8s.io/client-go/plugin/pkg/client/auth/oidc" ctrl "sigs.k8s.io/controller-runtime" "sigs.k8s.io/controller-runtime/pkg/cache" - "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/healthz" "sigs.k8s.io/controller-runtime/pkg/log/zap" "sigs.k8s.io/controller-runtime/pkg/manager" @@ -160,14 +157,6 @@ func main() { } func configureHealthChecks(ctx context.Context, mgr manager.Manager) error { - // Register existing watches before startup so initial cache sync cannot be empty. - for _, object := range []client.Object{ - &api.ZookeeperCluster{}, &appsv1.StatefulSet{}, &corev1.Service{}, &corev1.Pod{}, - } { - if _, err := mgr.GetCache().GetInformer(ctx, object, cache.BlockUntilSynced(false)); err != nil { - return fmt.Errorf("initialize probe cache: %w", err) - } - } if err := mgr.AddHealthzCheck("ping", healthz.Ping); err != nil { return err }