introduce TypedName to reduce boilerplate, modify plugins

Signed-off-by: Etai Lev Ran <[email protected]>

Author: elevran

conformance/testing-epp/plugins/filter/request_header_based_filter.go

@@ -20,6 +20,7 @@ import (
 	"context"
 	"strings"
 
+	"sigs.k8s.io/gateway-api-inference-extension/pkg/epp/plugins"
 	"sigs.k8s.io/gateway-api-inference-extension/pkg/epp/scheduling/framework"
 	"sigs.k8s.io/gateway-api-inference-extension/pkg/epp/scheduling/types"
 )
@@ -38,20 +39,14 @@ var _ framework.Filter = &HeaderBasedTestingFilter{}
 // NewHeaderBasedTestingFilter initializes a new HeaderBasedTestingFilter.
 // This should only be used for testing purposes.
 func NewHeaderBasedTestingFilter() *HeaderBasedTestingFilter {
-	return &HeaderBasedTestingFilter{}
+	return &HeaderBasedTestingFilter{
+		TypedName: plugins.NewTypedName("header-based-testing", "header-based-testing-filter"),
+	}
 }
 
 // HeaderBasedTestingFilter filters Pods based on an address specified in the "test-epp-endpoint-selection" request header.
-type HeaderBasedTestingFilter struct{}
-
-// Type returns the type of the filter.
-func (f *HeaderBasedTestingFilter) Type() string {
-	return "header-based-testing"
-}
-
-// Name returns the type of the filter.
-func (f *HeaderBasedTestingFilter) Name() string {
-	return "header-based-testing-filter"
+type HeaderBasedTestingFilter struct {
+	plugins.TypedName
 }
 
 // Filter selects pods that match the IP addresses specified in the request header.

pkg/epp/common/config/loader/configloader_test.go

@@ -555,15 +555,14 @@ schedulingProfiles:
 var _ framework.Filter = &test1{}
 
 type test1 struct {
+	plugins.TypedName
 	Threshold int `json:"threshold"`
 }
 
-func (f *test1) Type() string {
-	return test1Type
-}
-
-func (f *test1) Name() string {
-	return "test-1"
+func newTest1() *test1 {
+	return &test1{
+		TypedName: plugins.NewTypedName(test1Type, "test-1"),
+	}
 }
 
 // Filter filters out pods that doesn't meet the filter criteria.
@@ -575,14 +574,14 @@ func (f *test1) Filter(_ context.Context, _ *types.CycleState, _ *types.LLMReque
 var _ framework.Scorer = &test2{}
 var _ framework.PostCycle = &test2{}
 
-type test2 struct{}
-
-func (f *test2) Type() string {
-	return test2Type
+type test2 struct {
+	plugins.TypedName
 }
 
-func (f *test2) Name() string {
-	return "test-2"
+func newTest2() *test2 {
+	return &test2{
+		TypedName: plugins.NewTypedName(test2Type, "test-2"),
+	}
 }
 
 func (m *test2) Score(_ context.Context, _ *types.CycleState, _ *types.LLMRequest, _ []types.Pod) map[types.Pod]float64 {
@@ -594,14 +593,14 @@ func (m *test2) PostCycle(_ context.Context, _ *types.CycleState, _ *types.Profi
 // compile-time type validation
 var _ framework.Picker = &testPicker{}
 
-type testPicker struct{}
-
-func (p *testPicker) Type() string {
-	return testPickerType
+type testPicker struct {
+	plugins.TypedName
 }
 
-func (p *testPicker) Name() string {
-	return "test-picker"
+func newTestPicker() *testPicker {
+	return &testPicker{
+		TypedName: plugins.NewTypedName(testPickerType, "test-picker"),
+	}
 }
 
 func (p *testPicker) Pick(_ context.Context, _ *types.CycleState, _ []*types.ScoredPod) *types.ProfileRunResult {
@@ -611,14 +610,14 @@ func (p *testPicker) Pick(_ context.Context, _ *types.CycleState, _ []*types.Sco
 // compile-time type validation
 var _ framework.ProfileHandler = &testProfileHandler{}
 
-type testProfileHandler struct{}
-
-func (p *testProfileHandler) Type() string {
-	return testProfileHandlerType
+type testProfileHandler struct {
+	plugins.TypedName
 }
 
-func (p *testProfileHandler) Name() string {
-	return "test-profile-handler"
+func newTestProfileHandler() *testProfileHandler {
+	return &testProfileHandler{
+		TypedName: plugins.NewTypedName(testProfileHandlerType, "test-profile-handler"),
+	}
 }
 
 func (p *testProfileHandler) Pick(_ context.Context, _ *types.CycleState, _ *types.LLMRequest, _ map[string]*framework.SchedulerProfile, _ map[string]*types.ProfileRunResult) map[string]*framework.SchedulerProfile {
@@ -631,28 +630,28 @@ func (p *testProfileHandler) ProcessResults(_ context.Context, _ *types.CycleSta
 
 func registerTestPlugins() {
 	plugins.Register(test1Type,
-		func(name string, parameters json.RawMessage, handle plugins.Handle) (plugins.Plugin, error) {
-			result := test1{}
-			err := json.Unmarshal(parameters, &result)
-			return &result, err
+		func(_ string, parameters json.RawMessage, _ plugins.Handle) (plugins.Plugin, error) {
+			result := newTest1()
+			err := json.Unmarshal(parameters, result)
+			return result, err
 		},
 	)
 
 	plugins.Register(test2Type,
-		func(name string, parameters json.RawMessage, handle plugins.Handle) (plugins.Plugin, error) {
-			return &test2{}, nil
+		func(_ string, _ json.RawMessage, _ plugins.Handle) (plugins.Plugin, error) {
+			return newTest2(), nil
 		},
 	)
 
 	plugins.Register(testPickerType,
-		func(name string, parameters json.RawMessage, handle plugins.Handle) (plugins.Plugin, error) {
-			return &testPicker{}, nil
+		func(_ string, _ json.RawMessage, _ plugins.Handle) (plugins.Plugin, error) {
+			return newTestPicker(), nil
 		},
 	)
 
 	plugins.Register(testProfileHandlerType,
-		func(name string, parameters json.RawMessage, handle plugins.Handle) (plugins.Plugin, error) {
-			return &testProfileHandler{}, nil
+		func(_ string, _ json.RawMessage, _ plugins.Handle) (plugins.Plugin, error) {
+			return newTestProfileHandler(), nil
 		},
 	)
 }

pkg/epp/plugins/typedname.go

@@ -0,0 +1,50 @@
+/*
+Copyright 2025 The Kubernetes 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 plugins
+
+// TypedName is a utility struct providing a type and a name
+// to plugins.
+// It implements the Plugin interface and can be embedded in
+// plugins across the code to reduce boilerplate.
+type TypedName struct {
+	objType string
+	objName string
+}
+
+// NewTypedName returns a new TypedName struct configured with
+// the given type and name.
+func NewTypedName(objtype, objname string) TypedName {
+	return TypedName{
+		objType: objtype,
+		objName: objname,
+	}
+}
+
+// Type returns the type of the plugin.
+func (tn *TypedName) Type() string {
+	return tn.objType
+}
+
+// Name returns the name of this plugin instance.
+func (tn *TypedName) Name() string {
+	return tn.objName
+}
+
+// SetName sets the instance name.
+func (tn *TypedName) SetName(name string) {
+	tn.objName = name
+}

pkg/epp/requestcontrol/director_test.go

@@ -37,6 +37,7 @@ import (
 	backendmetrics "sigs.k8s.io/gateway-api-inference-extension/pkg/epp/backend/metrics"
 	"sigs.k8s.io/gateway-api-inference-extension/pkg/epp/datastore"
 	"sigs.k8s.io/gateway-api-inference-extension/pkg/epp/handlers"
+	"sigs.k8s.io/gateway-api-inference-extension/pkg/epp/plugins"
 	schedulingtypes "sigs.k8s.io/gateway-api-inference-extension/pkg/epp/scheduling/types"
 	errutil "sigs.k8s.io/gateway-api-inference-extension/pkg/epp/util/error"
 	logutil "sigs.k8s.io/gateway-api-inference-extension/pkg/epp/util/logging"
@@ -653,9 +654,7 @@ func pointer(v int32) *int32 {
 }
 
 func TestDirector_HandleResponse(t *testing.T) {
-	pr1 := &testPostResponse{
-		TypeRes: "pr1",
-	}
+	pr1 := newTestPostResponse("pr1")
 
 	ctx := logutil.NewTestLoggerIntoContext(context.Background())
 	ds := datastore.NewDatastore(t.Context(), nil)
@@ -691,14 +690,21 @@ func TestDirector_HandleResponse(t *testing.T) {
 	}
 }
 
+const (
+	testPostResponseType = "test-post-response"
+)
+
 type testPostResponse struct {
-	TypeRes                 string
+	plugins.TypedName
 	lastRespOnResponse      *Response
 	lastTargetPodOnResponse string
 }
 
-func (p *testPostResponse) Type() string { return p.TypeRes }
-func (p *testPostResponse) Name() string { return "test-post-response" }
+func newTestPostResponse(name string) *testPostResponse {
+	return &testPostResponse{
+		TypedName: plugins.NewTypedName(testPostResponseType, name),
+	}
+}
 
 func (p *testPostResponse) PostResponse(_ context.Context, _ *schedulingtypes.LLMRequest, response *Response, targetPod *backend.Pod) {
 	p.lastRespOnResponse = response

pkg/epp/scheduling/framework/plugins/filter/decision_tree_filter.go

@@ -36,9 +36,11 @@ const (
 // compile-time type assertion
 var _ framework.Filter = &DecisionTreeFilter{}
 
-// DecisionTreeFilter applies current fitler, and then recursively applies next filters
+// DecisionTreeFilter applies current filter, and then recursively applies next filters
 // depending success or failure of the current filter.
 // It can be used to construct a flow chart algorithm.
+// Since a DecisionTreeFilter takes on the type and name of the current filter,
+// it is not embedding a fixed plugins.TypeName.
 type DecisionTreeFilter struct {
 	Current framework.Filter
 	// NextOnSuccess filter will be applied after successfully applying the current filter.