Merge pull request #6645 from liaolecheng/automated-cherry-pick-of-#6602-#6612-#6626-upstream-release-1.14

Automated cherry pick of  #6602 #6612 #6626 on release-1.14

Author: karmada-bot

cmd/agent/app/agent.go

@@ -260,10 +260,9 @@ func setupControllers(ctx context.Context, mgr controllerruntime.Manager, opts *
 	sharedFactory.WaitForCacheSync(ctx.Done())
 
 	resourceInterpreter := resourceinterpreter.NewResourceInterpreter(controlPlaneInformerManager, serviceLister)
-	if err := mgr.Add(resourceInterpreter); err != nil {
-		return fmt.Errorf("failed to setup custom resource interpreter: %w", err)
+	if err := resourceInterpreter.Start(ctx); err != nil {
+		return fmt.Errorf("failed to start resource interpreter: %w", err)
 	}
-
 	rateLimiterGetter := util.GetClusterRateLimiterGetter().SetDefaultLimits(opts.ClusterAPIQPS, opts.ClusterAPIBurst)
 	clusterClientOption := &util.ClientOption{RateLimiterGetter: rateLimiterGetter.GetRateLimiter}
 

cmd/controller-manager/app/controllermanager.go

@@ -839,8 +839,8 @@ func setupControllers(ctx context.Context, mgr controllerruntime.Manager, opts *
 	sharedFactory.WaitForCacheSync(ctx.Done())
 
 	resourceInterpreter := resourceinterpreter.NewResourceInterpreter(controlPlaneInformerManager, serviceLister)
-	if err := mgr.Add(resourceInterpreter); err != nil {
-		klog.Fatalf("Failed to setup custom resource interpreter: %v", err)
+	if err := resourceInterpreter.Start(ctx); err != nil {
+		klog.Fatalf("Failed to start resource interpreter: %v", err)
 	}
 	rateLimiterGetter := util.GetClusterRateLimiterGetter().SetDefaultLimits(opts.ClusterAPIQPS, opts.ClusterAPIBurst)
 	clusterClientOption := &util.ClientOption{RateLimiterGetter: rateLimiterGetter.GetRateLimiter}

pkg/resourceinterpreter/customized/declarative/configmanager/manager.go

@@ -17,38 +17,38 @@ limitations under the License.
 package configmanager
 
 import (
-	"fmt"
+	"errors"
 	"sort"
 	"sync/atomic"
 
 	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apimachinery/pkg/runtime/schema"
-	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
 	"k8s.io/client-go/tools/cache"
 	"k8s.io/klog/v2"
 
 	configv1alpha1 "github.com/karmada-io/karmada/pkg/apis/config/v1alpha1"
+	"github.com/karmada-io/karmada/pkg/util"
 	"github.com/karmada-io/karmada/pkg/util/fedinformer"
 	"github.com/karmada-io/karmada/pkg/util/fedinformer/genericmanager"
 	"github.com/karmada-io/karmada/pkg/util/helper"
 )
 
-var resourceInterpreterCustomizationsGVR = schema.GroupVersionResource{
-	Group:    configv1alpha1.GroupVersion.Group,
-	Version:  configv1alpha1.GroupVersion.Version,
-	Resource: "resourceinterpretercustomizations",
-}
-
 // ConfigManager can list custom resource interpreter.
 type ConfigManager interface {
 	CustomAccessors() map[schema.GroupVersionKind]CustomAccessor
 	HasSynced() bool
+	// LoadConfig is used to load ResourceInterpreterCustomization into the cache,
+	// it requires the provided customizations to be a full list of objects.
+	// It is recommended to be called during startup. After called, HasSynced() will always
+	// return true, and CustomAccessors() will return a map of CustomAccessor containing
+	// all ResourceInterpreterCustomization configurations.
 	LoadConfig(customizations []*configv1alpha1.ResourceInterpreterCustomization)
 }
 
 // interpreterConfigManager collects the resource interpreter customization.
 type interpreterConfigManager struct {
 	initialSynced atomic.Bool
+	informer      genericmanager.SingleClusterInformerManager
 	lister        cache.GenericLister
 	configuration atomic.Value
 }
@@ -64,16 +64,12 @@ func (configManager *interpreterConfigManager) HasSynced() bool {
 		return true
 	}
 
-	if configuration, err := configManager.lister.List(labels.Everything()); err == nil && len(configuration) == 0 {
-		// the empty list we initially stored is valid to use.
-		// Setting initialSynced to true, so subsequent checks
-		// would be able to take the fast path on the atomic boolean in a
-		// cluster without any customization configured.
-		configManager.initialSynced.Store(true)
-		// the informer has synced, and we don't have any items
-		return true
+	err := configManager.updateConfiguration()
+	if err != nil {
+		klog.ErrorS(err, "error updating configuration")
+		return false
 	}
-	return false
+	return true
 }
 
 // NewInterpreterConfigManager watches ResourceInterpreterCustomization and organizes
@@ -84,35 +80,48 @@ func NewInterpreterConfigManager(informer genericmanager.SingleClusterInformerMa
 
 	// In interpret command, rules are not loaded from server, so we don't start informer for it.
 	if informer != nil {
-		manager.lister = informer.Lister(resourceInterpreterCustomizationsGVR)
+		manager.informer = informer
+		manager.lister = informer.Lister(util.ResourceInterpreterCustomizationsGVR)
 		configHandlers := fedinformer.NewHandlerOnEvents(
-			func(_ interface{}) { manager.updateConfiguration() },
-			func(_, _ interface{}) { manager.updateConfiguration() },
-			func(_ interface{}) { manager.updateConfiguration() })
-		informer.ForResource(resourceInterpreterCustomizationsGVR, configHandlers)
+			func(_ interface{}) { _ = manager.updateConfiguration() },
+			func(_, _ interface{}) { _ = manager.updateConfiguration() },
+			func(_ interface{}) { _ = manager.updateConfiguration() })
+		informer.ForResource(util.ResourceInterpreterCustomizationsGVR, configHandlers)
 	}
 
 	return manager
 }
 
-func (configManager *interpreterConfigManager) updateConfiguration() {
+// updateConfiguration is used as the event handler for the ResourceInterpreterCustomization resource.
+// Any changes (add, update, delete) to these resources will trigger this method, which loads all
+// ResourceInterpreterCustomization resources and refreshes the internal cache accordingly.
+// Note: During startup, some events may be missed if the informer has not yet synced. If all events
+// are missed during startup, updateConfiguration will be called when HasSynced() is invoked for the
+// first time, ensuring the cache is updated on first use.
+func (configManager *interpreterConfigManager) updateConfiguration() error {
+	if configManager.informer == nil {
+		return errors.New("informer manager is not configured")
+	}
+	if !configManager.informer.IsInformerSynced(util.ResourceInterpreterCustomizationsGVR) {
+		return errors.New("informer of ResourceInterpreterCustomization not synced")
+	}
+
 	configurations, err := configManager.lister.List(labels.Everything())
 	if err != nil {
-		utilruntime.HandleError(fmt.Errorf("error updating configuration: %v", err))
-		return
+		return err
 	}
 
 	configs := make([]*configv1alpha1.ResourceInterpreterCustomization, len(configurations))
 	for index, c := range configurations {
 		config := &configv1alpha1.ResourceInterpreterCustomization{}
 		if err = helper.ConvertToTypedObject(c, config); err != nil {
-			klog.Errorf("Failed to transform ResourceInterpreterCustomization: %v", err)
-			return
+			return err
 		}
 		configs[index] = config
 	}
 
 	configManager.LoadConfig(configs)
+	return nil
 }
 
 func (configManager *interpreterConfigManager) LoadConfig(configs []*configv1alpha1.ResourceInterpreterCustomization) {