From 5c4948ff3140519baa068511bc219d179fd1303d Mon Sep 17 00:00:00 2001 From: xigang Date: Mon, 17 Mar 2025 19:56:07 +0800 Subject: [PATCH] controller: factor out pod node name indexer helper function Signed-off-by: xigang --- pkg/controller/controller_utils.go | 25 +++++++++++++++++++ .../node_lifecycle_controller.go | 19 +++----------- 2 files changed, 28 insertions(+), 16 deletions(-) diff --git a/pkg/controller/controller_utils.go b/pkg/controller/controller_utils.go index 9088bfd692e..9da6c6a1048 100644 --- a/pkg/controller/controller_utils.go +++ b/pkg/controller/controller_utils.go @@ -83,6 +83,9 @@ const ( // The number of batches is given by: // 1+floor(log_2(ceil(N/SlowStartInitialBatchSize))) SlowStartInitialBatchSize = 1 + + // PodNodeNameKeyIndex is the name of the index used by PodInformer to index pods by their node name. + PodNodeNameKeyIndex = "spec.nodeName" ) var UpdateTaintBackoff = wait.Backoff{ @@ -1051,6 +1054,28 @@ func FilterReplicaSets(RSes []*apps.ReplicaSet, filterFn filterRS) []*apps.Repli return filtered } +// AddPodNodeNameIndexer adds an indexer for Pod's nodeName to the given PodInformer. +// This indexer is used to efficiently look up pods by their node name. +func AddPodNodeNameIndexer(podInformer cache.SharedIndexInformer) error { + if _, exists := podInformer.GetIndexer().GetIndexers()[PodNodeNameKeyIndex]; exists { + // indexer already exists, do nothing + return nil + } + + return podInformer.AddIndexers(cache.Indexers{ + PodNodeNameKeyIndex: func(obj interface{}) ([]string, error) { + pod, ok := obj.(*v1.Pod) + if !ok { + return []string{}, nil + } + if len(pod.Spec.NodeName) == 0 { + return []string{}, nil + } + return []string{pod.Spec.NodeName}, nil + }, + }) +} + // PodKey returns a key unique to the given pod within a cluster. // It's used so we consistently use the same key scheme in this module. // It does exactly what cache.MetaNamespaceKeyFunc would have done diff --git a/pkg/controller/nodelifecycle/node_lifecycle_controller.go b/pkg/controller/nodelifecycle/node_lifecycle_controller.go index 957b7887100..24d68a8dfe6 100644 --- a/pkg/controller/nodelifecycle/node_lifecycle_controller.go +++ b/pkg/controller/nodelifecycle/node_lifecycle_controller.go @@ -125,8 +125,7 @@ const ( const ( // The amount of time the nodecontroller should sleep between retrying node health updates - retrySleepTime = 20 * time.Millisecond - nodeNameKeyIndex = "spec.nodeName" + retrySleepTime = 20 * time.Millisecond // podUpdateWorkerSizes assumes that in most cases pod will be handled by monitorNodeHealth pass. // Pod update workers will only handle lagging cache pods. 4 workers should be enough. podUpdateWorkerSize = 4 @@ -388,22 +387,10 @@ func NewNodeLifecycleController( }, }) nc.podInformerSynced = podInformer.Informer().HasSynced - podInformer.Informer().AddIndexers(cache.Indexers{ - nodeNameKeyIndex: func(obj interface{}) ([]string, error) { - pod, ok := obj.(*v1.Pod) - if !ok { - return []string{}, nil - } - if len(pod.Spec.NodeName) == 0 { - return []string{}, nil - } - return []string{pod.Spec.NodeName}, nil - }, - }) - + controller.AddPodNodeNameIndexer(podInformer.Informer()) podIndexer := podInformer.Informer().GetIndexer() nc.getPodsAssignedToNode = func(nodeName string) ([]*v1.Pod, error) { - objs, err := podIndexer.ByIndex(nodeNameKeyIndex, nodeName) + objs, err := podIndexer.ByIndex(controller.PodNodeNameKeyIndex, nodeName) if err != nil { return nil, err }