move readiness check function to informer manager package

Signed-off-by: Wei Weng <Wei.Weng@microsoft.com>

Author: Wei Weng

cmd/hubagent/main.go

@@ -46,6 +46,7 @@ import (
 	"github.com/kubefleet-dev/kubefleet/cmd/hubagent/options"
 	"github.com/kubefleet-dev/kubefleet/cmd/hubagent/workload"
 	mcv1beta1 "github.com/kubefleet-dev/kubefleet/pkg/controllers/membercluster/v1beta1"
+	"github.com/kubefleet-dev/kubefleet/pkg/utils/informer"
 	"github.com/kubefleet-dev/kubefleet/pkg/utils/validator"
 	"github.com/kubefleet-dev/kubefleet/pkg/webhook"
 	// +kubebuilder:scaffold:imports
@@ -175,7 +176,7 @@ func main() {
 	// which is critical for all controllers that rely on dynamic resource discovery.
 	// AddReadyzCheck adds additional readiness check instead of replacing the one registered earlier provided the name is different.
 	// Both registered checks need to pass for the manager to be considered ready.
-	if err := mgr.AddReadyzCheck("informer-cache", webhook.ResourceInformerReadinessChecker(validator.ResourceInformer)); err != nil {
+	if err := mgr.AddReadyzCheck("informer-cache", informer.ReadinessChecker(validator.ResourceInformer)); err != nil {
 		klog.ErrorS(err, "unable to set up informer cache readiness check")
 		exitWithErrorFunc()
 	}

pkg/utils/informer/informermanager.go

@@ -19,6 +19,7 @@ package informer
 import (
 	"context"
 	"fmt"
+	"net/http"
 	"sync"
 	"time"
 
@@ -198,6 +199,40 @@ func (s *informerManagerImpl) IsInformerSynced(resource schema.GroupVersionResou
 	return s.informerFactory.ForResource(resource).Informer().HasSynced()
 }
 
+// ReadinessChecker creates a readiness check function that verifies
+// all resource informer caches are synced before marking the pod as ready.
+// This prevents components from processing requests before the discovery cache is populated.
+func ReadinessChecker(resourceInformer Manager) func(*http.Request) error {
+	return func(_ *http.Request) error {
+		if resourceInformer == nil {
+			return fmt.Errorf("resource informer not initialized")
+		}
+
+		// Require ALL informer caches to be synced before marking ready
+		allResources := resourceInformer.GetAllResources()
+		if len(allResources) == 0 {
+			// This can happen during startup when the ResourceInformer is created but the ChangeDetector
+			// hasn't discovered and registered any resources yet via AddDynamicResources().
+			return fmt.Errorf("resource informer not ready: no resources registered")
+		}
+
+		// Check that ALL informers have synced
+		unsyncedResources := []schema.GroupVersionResource{}
+		for _, gvr := range allResources {
+			if !resourceInformer.IsInformerSynced(gvr) {
+				unsyncedResources = append(unsyncedResources, gvr)
+			}
+		}
+
+		if len(unsyncedResources) > 0 {
+			return fmt.Errorf("resource informer not ready: %d/%d informers not synced yet", len(unsyncedResources), len(allResources))
+		}
+
+		klog.V(5).InfoS("All resource informers synced", "totalInformers", len(allResources))
+		return nil
+	}
+}
+
 func (s *informerManagerImpl) Lister(resource schema.GroupVersionResource) cache.GenericLister {
 	return s.informerFactory.ForResource(resource).Lister()
 }

pkg/utils/informer/readiness_test.go

@@ -0,0 +1,186 @@
+/*
+Copyright 2025 The KubeFleet Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package informer
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/client-go/dynamic"
+	"k8s.io/client-go/tools/cache"
+)
+
+// mockInformerManager is a simple mock for testing
+type mockInformerManager struct {
+	allResources []schema.GroupVersionResource
+	syncedMap    map[schema.GroupVersionResource]bool
+}
+
+func (m *mockInformerManager) AddDynamicResources(resources []APIResourceMeta, handler cache.ResourceEventHandler, listComplete bool) {
+}
+func (m *mockInformerManager) AddStaticResource(resource APIResourceMeta, handler cache.ResourceEventHandler) {
+}
+func (m *mockInformerManager) IsInformerSynced(resource schema.GroupVersionResource) bool {
+	if m.syncedMap == nil {
+		return false
+	}
+	synced, exists := m.syncedMap[resource]
+	return exists && synced
+}
+func (m *mockInformerManager) Start() {}
+func (m *mockInformerManager) Stop()  {}
+func (m *mockInformerManager) Lister(resource schema.GroupVersionResource) cache.GenericLister {
+	return nil
+}
+func (m *mockInformerManager) GetNameSpaceScopedResources() []schema.GroupVersionResource { return nil }
+func (m *mockInformerManager) GetAllResources() []schema.GroupVersionResource {
+	return m.allResources
+}
+func (m *mockInformerManager) IsClusterScopedResources(resource schema.GroupVersionKind) bool {
+	return false
+}
+func (m *mockInformerManager) WaitForCacheSync()            {}
+func (m *mockInformerManager) GetClient() dynamic.Interface { return nil }
+
+func TestReadinessChecker(t *testing.T) {
+	tests := []struct {
+		name             string
+		resourceInformer Manager
+		expectError      bool
+		errorContains    string
+	}{
+		{
+			name:             "nil informer",
+			resourceInformer: nil,
+			expectError:      true,
+			errorContains:    "resource informer not initialized",
+		},
+		{
+			name: "no resources registered",
+			resourceInformer: &mockInformerManager{
+				allResources: []schema.GroupVersionResource{},
+			},
+			expectError:   true,
+			errorContains: "no resources registered",
+		},
+		{
+			name: "all informers synced",
+			resourceInformer: &mockInformerManager{
+				allResources: []schema.GroupVersionResource{
+					{Group: "", Version: "v1", Resource: "configmaps"},
+					{Group: "", Version: "v1", Resource: "secrets"},
+					{Group: "", Version: "v1", Resource: "namespaces"},
+				},
+				syncedMap: map[schema.GroupVersionResource]bool{
+					{Group: "", Version: "v1", Resource: "configmaps"}: true,
+					{Group: "", Version: "v1", Resource: "secrets"}:    true,
+					{Group: "", Version: "v1", Resource: "namespaces"}: true,
+				},
+			},
+			expectError: false,
+		},
+		{
+			name: "some informers not synced",
+			resourceInformer: &mockInformerManager{
+				allResources: []schema.GroupVersionResource{
+					{Group: "", Version: "v1", Resource: "configmaps"},
+					{Group: "", Version: "v1", Resource: "secrets"},
+					{Group: "", Version: "v1", Resource: "namespaces"},
+				},
+				syncedMap: map[schema.GroupVersionResource]bool{
+					{Group: "", Version: "v1", Resource: "configmaps"}: true,
+					{Group: "", Version: "v1", Resource: "secrets"}:    false,
+					{Group: "", Version: "v1", Resource: "namespaces"}: true,
+				},
+			},
+			expectError:   true,
+			errorContains: "informers not synced yet",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			checker := ReadinessChecker(tt.resourceInformer)
+			err := checker(nil)
+
+			if tt.expectError {
+				assert.Error(t, err)
+				if tt.errorContains != "" {
+					assert.Contains(t, err.Error(), tt.errorContains)
+				}
+			} else {
+				assert.NoError(t, err)
+			}
+		})
+	}
+}
+
+func TestReadinessChecker_PartialSync(t *testing.T) {
+	// Test the case where we have multiple resources but only some are synced
+	mockManager := &mockInformerManager{
+		allResources: []schema.GroupVersionResource{
+			{Group: "", Version: "v1", Resource: "configmaps"},
+			{Group: "", Version: "v1", Resource: "secrets"},
+			{Group: "apps", Version: "v1", Resource: "deployments"},
+			{Group: "", Version: "v1", Resource: "namespaces"},
+		},
+		syncedMap: map[schema.GroupVersionResource]bool{
+			{Group: "", Version: "v1", Resource: "configmaps"}:      false,
+			{Group: "", Version: "v1", Resource: "secrets"}:         false,
+			{Group: "apps", Version: "v1", Resource: "deployments"}: false,
+			{Group: "", Version: "v1", Resource: "namespaces"}:      false,
+		},
+	}
+
+	checker := ReadinessChecker(mockManager)
+	err := checker(nil)
+
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "informers not synced yet")
+	// Should report 4 unsynced
+	assert.Contains(t, err.Error(), "4/4")
+}
+
+func TestReadinessChecker_AllSyncedMultipleResources(t *testing.T) {
+	// Test with many resources all synced
+	mockManager := &mockInformerManager{
+		allResources: []schema.GroupVersionResource{
+			{Group: "", Version: "v1", Resource: "configmaps"},
+			{Group: "", Version: "v1", Resource: "secrets"},
+			{Group: "", Version: "v1", Resource: "services"},
+			{Group: "apps", Version: "v1", Resource: "deployments"},
+			{Group: "apps", Version: "v1", Resource: "statefulsets"},
+			{Group: "", Version: "v1", Resource: "namespaces"},
+			{Group: "rbac.authorization.k8s.io", Version: "v1", Resource: "clusterroles"},
+		},
+		syncedMap: map[schema.GroupVersionResource]bool{
+			{Group: "", Version: "v1", Resource: "configmaps"}:                            true,
+			{Group: "", Version: "v1", Resource: "secrets"}:                               true,
+			{Group: "", Version: "v1", Resource: "services"}:                              true,
+			{Group: "apps", Version: "v1", Resource: "deployments"}:                       true,
+			{Group: "apps", Version: "v1", Resource: "statefulsets"}:                      true,
+			{Group: "", Version: "v1", Resource: "namespaces"}:                            true,
+			{Group: "rbac.authorization.k8s.io", Version: "v1", Resource: "clusterroles"}: true,
+		},
+	}
+
+	checker := ReadinessChecker(mockManager)
+	err := checker(nil)
+
+	assert.NoError(t, err, "Should be ready when all informers are synced")
+}