feat(pkg/descheduler): create profiles outside the descheduling cycle

Each plugin is expected to be built only once within a profile.
This way informers and indexers can be registered before the shared
informer factory is started. Including registration of event handlers
as well. Allowing plugins to take part in the descheduler initialization.

Author: ingvagabund

pkg/descheduler/descheduler.go

@@ -94,6 +94,7 @@ type descheduler struct {
 	queue                             workqueue.RateLimitingInterface
 	currentPrometheusAuthToken        string
 	metricsProviders                  map[api.MetricsSource]*api.MetricsProvider
+	profileRunners                    []profileRunner
 }
 
 func nodeSelectorFromPolicy(deschedulerPolicy *api.DeschedulerPolicy) (labels.Selector, error) {
@@ -195,6 +196,29 @@ func newDescheduler(ctx context.Context, rs *options.DeschedulerServer, deschedu
 		desch.metricsCollector = metricscollector.NewMetricsCollector(sharedInformerFactory.Core().V1().Nodes().Lister(), rs.MetricsClient, nodeSelector)
 	}
 
+	var profileRunners []profileRunner
+	for idx, profile := range deschedulerPolicy.Profiles {
+		currProfile, err := frameworkprofile.NewProfile(
+			ctx,
+			profile,
+			pluginregistry.PluginRegistry,
+			frameworkprofile.WithClientSet(desch.client),
+			frameworkprofile.WithSharedInformerFactory(desch.sharedInformerFactory),
+			frameworkprofile.WithPodEvictor(desch.podEvictor),
+			frameworkprofile.WithGetPodsAssignedToNodeFnc(desch.getPodsAssignedToNode),
+			frameworkprofile.WithMetricsCollector(desch.metricsCollector),
+			frameworkprofile.WithPrometheusClient(desch.prometheusClient),
+			// Generate a unique instance ID using just the index to avoid long IDs
+			// when profile names are very long
+			frameworkprofile.WithProfileInstanceID(fmt.Sprintf("%d", idx)),
+		)
+		if err != nil {
+			return nil, fmt.Errorf("unable to create a profile %q: %w", profile.Name, err)
+		}
+		profileRunners = append(profileRunners, profileRunner{profile.Name, currProfile.RunDeschedulePlugins, currProfile.RunBalancePlugins})
+	}
+	desch.profileRunners = profileRunners
+
 	return desch, nil
 }
 
@@ -368,30 +392,7 @@ func (d *descheduler) runProfiles(ctx context.Context) {
 		return // gracefully skip this cycle instead of aborting
 	}
 
-	var profileRunners []profileRunner
-	for idx, profile := range d.deschedulerPolicy.Profiles {
-		currProfile, err := frameworkprofile.NewProfile(
-			ctx,
-			profile,
-			pluginregistry.PluginRegistry,
-			frameworkprofile.WithClientSet(d.client),
-			frameworkprofile.WithSharedInformerFactory(d.sharedInformerFactory),
-			frameworkprofile.WithPodEvictor(d.podEvictor),
-			frameworkprofile.WithGetPodsAssignedToNodeFnc(d.getPodsAssignedToNode),
-			frameworkprofile.WithMetricsCollector(d.metricsCollector),
-			frameworkprofile.WithPrometheusClient(d.prometheusClient),
-			// Generate a unique instance ID using just the index to avoid long IDs
-			// when profile names are very long
-			frameworkprofile.WithProfileInstanceID(fmt.Sprintf("%d", idx)),
-		)
-		if err != nil {
-			klog.ErrorS(err, "unable to create a profile", "profile", profile.Name)
-			continue
-		}
-		profileRunners = append(profileRunners, profileRunner{profile.Name, currProfile.RunDeschedulePlugins, currProfile.RunBalancePlugins})
-	}
-
-	for _, profileR := range profileRunners {
+	for _, profileR := range d.profileRunners {
 		// First deschedule
 		status := profileR.descheduleEPs(ctx, nodes)
 		if status != nil && status.Err != nil {
@@ -401,7 +402,7 @@ func (d *descheduler) runProfiles(ctx context.Context) {
 		}
 	}
 
-	for _, profileR := range profileRunners {
+	for _, profileR := range d.profileRunners {
 		// Balance Later
 		status := profileR.balanceEPs(ctx, nodes)
 		if status != nil && status.Err != nil {

pkg/descheduler/descheduler_test.go

@@ -36,6 +36,7 @@ import (
 	"sigs.k8s.io/descheduler/pkg/api"
 	"sigs.k8s.io/descheduler/pkg/descheduler/evictions"
 	"sigs.k8s.io/descheduler/pkg/features"
+	fakeplugin "sigs.k8s.io/descheduler/pkg/framework/fake/plugin"
 	"sigs.k8s.io/descheduler/pkg/framework/pluginregistry"
 	"sigs.k8s.io/descheduler/pkg/framework/plugins/defaultevictor"
 	"sigs.k8s.io/descheduler/pkg/framework/plugins/nodeutilization"
@@ -1406,3 +1407,138 @@ func TestEvictedPodRestorationInDryRun(t *testing.T) {
 		klog.Infof("Evicted pods cache was cleared after restoration in cycle %d", i)
 	}
 }
+
+// TestPluginInformerRegistration tests that plugin-specific informers are registered during newDescheduler
+func TestPluginInformerRegistration(t *testing.T) {
+	testCases := []struct {
+		name   string
+		dryRun bool
+	}{
+		{
+			name:   "dry run disabled",
+			dryRun: false,
+		},
+		{
+			name:   "dry run enabled",
+			dryRun: true,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			ctx := context.Background()
+
+			initPluginRegistry()
+
+			// Define the custom informers that should be registered by the plugin
+			customInformers := []schema.GroupVersionResource{
+				{Group: "apps", Version: "v1", Resource: "daemonsets"},
+				{Group: "apps", Version: "v1", Resource: "replicasets"},
+				{Group: "apps", Version: "v1", Resource: "statefulsets"},
+			}
+
+			callbackInvoked := false
+			fakePlugin := &fakeplugin.FakePlugin{
+				PluginName: "TestPluginWithInformers",
+			}
+
+			// Register our mock plugin using NewPluginFncFromFakeWithReactor
+			pluginregistry.Register(
+				fakePlugin.PluginName,
+				fakeplugin.NewPluginFncFromFakeWithReactor(fakePlugin, func(action fakeplugin.ActionImpl) {
+					callbackInvoked = true
+					// Register custom informers using the loop
+					for _, gvr := range customInformers {
+						_, err := action.Handle().SharedInformerFactory().ForResource(gvr)
+						if err != nil {
+							panic(fmt.Sprintf("Failed to register informer for %s: %v", gvr.Resource, err))
+						}
+					}
+				}),
+				&fakeplugin.FakePlugin{},
+				&fakeplugin.FakePluginArgs{},
+				fakeplugin.ValidateFakePluginArgs,
+				fakeplugin.SetDefaults_FakePluginArgs,
+				pluginregistry.PluginRegistry,
+			)
+
+			deschedulerPolicy := &api.DeschedulerPolicy{
+				Profiles: []api.DeschedulerProfile{
+					{
+						Name: "test-profile",
+						PluginConfigs: []api.PluginConfig{
+							{
+								Name: defaultevictor.PluginName,
+								Args: &defaultevictor.DefaultEvictorArgs{},
+							},
+							{
+								Name: fakePlugin.PluginName,
+								Args: &fakeplugin.FakePluginArgs{},
+							},
+						},
+						Plugins: api.Plugins{
+							Filter: api.PluginSet{
+								Enabled: []string{defaultevictor.PluginName},
+							},
+							PreEvictionFilter: api.PluginSet{
+								Enabled: []string{defaultevictor.PluginName},
+							},
+							Deschedule: api.PluginSet{
+								Enabled: []string{fakePlugin.PluginName},
+							},
+						},
+					},
+				},
+			}
+
+			node1 := test.BuildTestNode("node1", 1000, 2000, 9, nil)
+			node2 := test.BuildTestNode("node2", 1000, 2000, 9, nil)
+
+			_, descheduler, _ := initDescheduler(t, ctx, initFeatureGates(), deschedulerPolicy, nil, tc.dryRun, node1, node2)
+
+			if !callbackInvoked {
+				t.Fatal("Expected plugin initialization callback to be invoked")
+			}
+
+			// Verify that custom informers were registered in the SharedInformerFactory
+			for _, gvr := range customInformers {
+				informer, err := descheduler.sharedInformerFactory.ForResource(gvr)
+				if err != nil {
+					t.Errorf("Expected %s informer to be registered in SharedInformerFactory, got error: %v", gvr.Resource, err)
+					continue
+				}
+
+				if informer.Informer() == nil {
+					t.Errorf("Expected %s informer to be registered in SharedInformerFactory", gvr.Resource)
+					continue
+				}
+
+				// Verify the informer is cached (same instance when retrieved again)
+				var informer2 informers.GenericInformer
+				informer2, err = descheduler.sharedInformerFactory.ForResource(gvr)
+				if err != nil {
+					t.Errorf("Expected %s informer to be cached in factory, got error: %v", gvr.Resource, err)
+					continue
+				}
+
+				if informer.Informer() != informer2.Informer() {
+					t.Errorf("Expected %s informer to be cached in factory", gvr.Resource)
+				}
+			}
+
+			// Verify profileRunners were created
+			if len(descheduler.profileRunners) == 0 {
+				t.Fatal("Expected profileRunners to be created, got empty slice")
+			}
+
+			if len(descheduler.profileRunners) != 1 {
+				t.Fatalf("Expected 1 profileRunner, got %d", len(descheduler.profileRunners))
+			}
+
+			// Verify profile name
+			if descheduler.profileRunners[0].name != "test-profile" {
+				t.Errorf("Expected profile name to be 'test-profile', got '%s'", descheduler.profileRunners[0].name)
+			}
+		})
+	}
+}