chore: drop plugin type from types and file

Signed-off-by: zxw <1020938856@qq.com>

Author: yyzxw

.gitignore

@@ -31,3 +31,5 @@ go.work.sum
 # IDE files
 .idea
 .vscode
+
+vendor

pkg/plugins/filter/by_label.go

@@ -11,24 +11,24 @@ import (
 )
 
 const (
-	// ByLabelFilterType is the type of the ByLabel filter
-	ByLabelFilterType = "by-label"
+	// ByLabelType is the type of the ByLabel filter
+	ByLabelType = "by-label"
 )
 
-type byLabelFilterParameters struct {
+type byLabelParameters struct {
 	Label         string   `json:"label"`
 	ValidValues   []string `json:"validValues"`
 	AllowsNoLabel bool     `json:"allowsNoLabel"`
 }
 
 var _ framework.Filter = &ByLabel{} // validate interface conformance
 
-// ByLabelFilterFactory defines the factory function for the ByLabelFilter
-func ByLabelFilterFactory(name string, rawParameters json.RawMessage, _ plugins.Handle) (plugins.Plugin, error) {
-	parameters := byLabelFilterParameters{}
+// ByLabelFactory defines the factory function for the ByLabelFilter
+func ByLabelFactory(name string, rawParameters json.RawMessage, _ plugins.Handle) (plugins.Plugin, error) {
+	parameters := byLabelParameters{}
 	if rawParameters != nil {
 		if err := json.Unmarshal(rawParameters, &parameters); err != nil {
-			return nil, fmt.Errorf("failed to parse the parameters of the '%s' filter - %w", ByLabelFilterType, err)
+			return nil, fmt.Errorf("failed to parse the parameters of the '%s' filter - %w", ByLabelType, err)
 		}
 	}
 	return NewByLabel(name, parameters.Label, parameters.AllowsNoLabel, parameters.ValidValues...), nil
@@ -47,7 +47,7 @@ func NewByLabel(name string, labelName string, allowsNoLabel bool, validValues .
 	}
 
 	return &ByLabel{
-		typedName:     plugins.TypedName{Type: ByLabelFilterType, Name: name},
+		typedName:     plugins.TypedName{Type: ByLabelType, Name: name},
 		labelName:     labelName,
 		allowsNoLabel: allowsNoLabel,
 		validValues:   validValuesMap,

pkg/plugins/filter/by_label_selector.go

@@ -14,8 +14,8 @@ import (
 )
 
 const (
-	// ByLabelSelectorFilterType is the type of the ByLabelsFilter
-	ByLabelSelectorFilterType = "by-label-selector"
+	// ByLabelSelectorType is the type of the ByLabelsFilter
+	ByLabelSelectorType = "by-label-selector"
 )
 
 // compile-time type assertion
@@ -26,7 +26,7 @@ func ByLabelSelectorFactory(name string, rawParameters json.RawMessage, _ plugin
 	parameters := metav1.LabelSelector{}
 	if rawParameters != nil {
 		if err := json.Unmarshal(rawParameters, &parameters); err != nil {
-			return nil, fmt.Errorf("failed to parse the parameters of the '%s' filter - %w", ByLabelSelectorFilterType, err)
+			return nil, fmt.Errorf("failed to parse the parameters of the '%s' filter - %w", ByLabelSelectorType, err)
 		}
 	}
 	return NewByLabelSelector(name, &parameters)
@@ -44,7 +44,7 @@ func NewByLabelSelector(name string, selector *metav1.LabelSelector) (*ByLabelSe
 	}
 
 	return &ByLabelSelector{
-		typedName: plugins.TypedName{Type: ByLabelSelectorFilterType, Name: name},
+		typedName: plugins.TypedName{Type: ByLabelSelectorType, Name: name},
 		selector:  labelSelector,
 	}, nil
 }

pkg/plugins/filter/pd_role.go

@@ -0,0 +1,43 @@
+package filter
+
+import (
+	"encoding/json"
+
+	"sigs.k8s.io/gateway-api-inference-extension/pkg/epp/plugins"
+)
+
+const (
+	// RoleLabel name
+	RoleLabel = "llm-d.ai/role"
+	// RolePrefill set for designated prefill workers
+	RolePrefill = "prefill"
+	// RoleDecode set for designated decode workers
+	RoleDecode = "decode"
+	// RoleBoth set for workers that can act as both prefill and decode
+	RoleBoth = "both"
+
+	// DecodeType is the type of the DecodeFilter
+	DecodeType = "decode-filter"
+	// PrefillType is the type of the PrefillFilter
+	PrefillType = "prefill-filter"
+)
+
+// PrefillFactory defines the factory function for the PrefillFilter
+func PrefillFactory(name string, _ json.RawMessage, _ plugins.Handle) (plugins.Plugin, error) {
+	return NewPrefill().WithName(name), nil
+}
+
+// NewPrefill creates and returns an instance of the Filter configured for prefill role
+func NewPrefill() *ByLabel {
+	return NewByLabel(PrefillType, RoleLabel, false, RolePrefill)
+}
+
+// DecodeFactory defines the factory function for the DecodeFilter
+func DecodeFactory(name string, _ json.RawMessage, _ plugins.Handle) (plugins.Plugin, error) {
+	return NewDecode().WithName(name), nil
+}
+
+// NewDecode creates and returns an instance of the Filter configured for decode role
+func NewDecode() *ByLabel {
+	return NewByLabel(DecodeType, RoleLabel, true, RoleDecode, RoleBoth)
+}

pkg/plugins/filter/pd_role_filter.go

@@ -12,13 +12,13 @@ import (
 
 // RegisterAllPlugins registers the factory functions of all plugins in this repository.
 func RegisterAllPlugins() {
-	plugins.Register(filter.ByLabelFilterType, filter.ByLabelFilterFactory)
-	plugins.Register(filter.ByLabelSelectorFilterType, filter.ByLabelSelectorFactory)
-	plugins.Register(filter.DecodeFilterType, filter.DecodeFilterFactory)
-	plugins.Register(filter.PrefillFilterType, filter.PrefillFilterFactory)
+	plugins.Register(filter.ByLabelType, filter.ByLabelFactory)
+	plugins.Register(filter.ByLabelSelectorType, filter.ByLabelSelectorFactory)
+	plugins.Register(filter.DecodeType, filter.DecodeFactory)
+	plugins.Register(filter.PrefillType, filter.PrefillFactory)
 	plugins.Register(prerequest.PrefillHeaderHandlerType, prerequest.PrefillHeaderHandlerFactory)
 	plugins.Register(profile.PdProfileHandlerType, profile.PdProfileHandlerFactory)
 	plugins.Register(prefix.PrefixCachePluginType, scorer.PrefixCachePluginFactory)
-	plugins.Register(scorer.LoadAwareScorerType, scorer.LoadAwareScorerFactory)
-	plugins.Register(scorer.SessionAffinityScorerType, scorer.SessionAffinityScorerFactory)
+	plugins.Register(scorer.LoadAwareType, scorer.LoadAwareFactory)
+	plugins.Register(scorer.SessionAffinityType, scorer.SessionAffinityFactory)
 }

pkg/plugins/register.go

@@ -13,58 +13,58 @@ import (
 )
 
 const (
-	// LoadAwareScorerType is the type of the LoadAwareScorer
-	LoadAwareScorerType = "load-aware-scorer"
+	// LoadAwareType is the type of the LoadAware
+	LoadAwareType = "load-aware-scorer"
 
 	// QueueThresholdDefault defines the default queue threshold value
 	QueueThresholdDefault = 128
 )
 
-type loadAwareScorerParameters struct {
+type loadAwareParameters struct {
 	Threshold int `json:"threshold"`
 }
 
 // compile-time type assertion
-var _ framework.Scorer = &LoadAwareScorer{}
+var _ framework.Scorer = &LoadAware{}
 
-// LoadAwareScorerFactory defines the factory function for the LoadAwareScorer
-func LoadAwareScorerFactory(name string, rawParameters json.RawMessage, handle plugins.Handle) (plugins.Plugin, error) {
-	parameters := loadAwareScorerParameters{Threshold: QueueThresholdDefault}
+// LoadAwareFactory defines the factory function for the LoadAware
+func LoadAwareFactory(name string, rawParameters json.RawMessage, handle plugins.Handle) (plugins.Plugin, error) {
+	parameters := loadAwareParameters{Threshold: QueueThresholdDefault}
 	if rawParameters != nil {
 		if err := json.Unmarshal(rawParameters, &parameters); err != nil {
-			return nil, fmt.Errorf("failed to parse the parameters of the '%s' scorer - %w", LoadAwareScorerType, err)
+			return nil, fmt.Errorf("failed to parse the parameters of the '%s' scorer - %w", LoadAwareType, err)
 		}
 	}
 
 	return NewLoadAwareScorer(handle.Context(), parameters.Threshold).WithName(name), nil
 }
 
 // NewLoadAwareScorer creates a new load based scorer
-func NewLoadAwareScorer(ctx context.Context, queueThreshold int) *LoadAwareScorer {
+func NewLoadAwareScorer(ctx context.Context, queueThreshold int) *LoadAware {
 	if queueThreshold <= 0 {
 		queueThreshold = QueueThresholdDefault
 		log.FromContext(ctx).V(logutil.DEFAULT).Info(fmt.Sprintf("queueThreshold %d should be positive, using default queue threshold %d", queueThreshold, QueueThresholdDefault))
 	}
 
-	return &LoadAwareScorer{
-		typedName:      plugins.TypedName{Type: LoadAwareScorerType},
+	return &LoadAware{
+		typedName:      plugins.TypedName{Type: LoadAwareType},
 		queueThreshold: float64(queueThreshold),
 	}
 }
 
-// LoadAwareScorer scorer that is based on load
-type LoadAwareScorer struct {
+// LoadAware scorer that is based on load
+type LoadAware struct {
 	typedName      plugins.TypedName
 	queueThreshold float64
 }
 
 // TypedName returns the typed name of the plugin.
-func (s *LoadAwareScorer) TypedName() plugins.TypedName {
+func (s *LoadAware) TypedName() plugins.TypedName {
 	return s.typedName
 }
 
 // WithName sets the name of the plugin.
-func (s *LoadAwareScorer) WithName(name string) *LoadAwareScorer {
+func (s *LoadAware) WithName(name string) *LoadAware {
 	s.typedName.Name = name
 	return s
 }
@@ -76,7 +76,7 @@ func (s *LoadAwareScorer) WithName(name string) *LoadAwareScorer {
 // Pod with requests in the queue will get score between 0.5 and 0.
 // Score 0 will get pod with number of requests in the queue equal to the threshold used in load-based filter
 // In the future, pods with additional capacity will get score higher than 0.5
-func (s *LoadAwareScorer) Score(_ context.Context, _ *types.CycleState, _ *types.LLMRequest, pods []types.Pod) map[types.Pod]float64 {
+func (s *LoadAware) Score(_ context.Context, _ *types.CycleState, _ *types.LLMRequest, pods []types.Pod) map[types.Pod]float64 {
 	scoredPods := make(map[types.Pod]float64)
 
 	for _, pod := range pods {

pkg/plugins/scorer/load_aware_scorer.go renamed to pkg/plugins/scorer/load_aware.go

@@ -15,8 +15,8 @@ import (
 )
 
 const (
-	// SessionAffinityScorerType is the type of the SessionAffinityScorer
-	SessionAffinityScorerType = "session-affinity-scorer"
+	// SessionAffinityType is the type of the SessionAffinityScorer
+	SessionAffinityType = "session-affinity-scorer"
 
 	sessionTokenHeader = "x-session-token" // name of the session header in request
 )
@@ -25,15 +25,15 @@ const (
 var _ framework.Scorer = &SessionAffinity{}
 var _ requestcontrol.PostResponse = &SessionAffinity{}
 
-// SessionAffinityScorerFactory defines the factory function for SessionAffinityScorer.
-func SessionAffinityScorerFactory(name string, _ json.RawMessage, _ plugins.Handle) (plugins.Plugin, error) {
+// SessionAffinityFactory defines the factory function for SessionAffinityScorer.
+func SessionAffinityFactory(name string, _ json.RawMessage, _ plugins.Handle) (plugins.Plugin, error) {
 	return NewSessionAffinity().WithName(name), nil
 }
 
 // NewSessionAffinity returns a scorer
 func NewSessionAffinity() *SessionAffinity {
 	return &SessionAffinity{
-		typedName: plugins.TypedName{Type: SessionAffinityScorerType},
+		typedName: plugins.TypedName{Type: SessionAffinityType},
 	}
 }
 

pkg/plugins/scorer/load_aware_scorer_test.go renamed to pkg/plugins/scorer/load_aware_test.go

@@ -198,13 +198,13 @@ func TestPDSchedule(t *testing.T) {
 			prefixScorer := prefix.New(prefix.Config{HashBlockSize: 5, MaxPrefixBlocksToMatch: 256, LRUCapacityPerServer: 31250})
 
 			prefillSchedulerProfile := framework.NewSchedulerProfile().
-				WithFilters(filter.NewPrefillFilter()).
+				WithFilters(filter.NewPrefill()).
 				WithPicker(picker.NewMaxScorePicker(picker.DefaultMaxNumOfEndpoints))
 			err := prefillSchedulerProfile.AddPlugins(framework.NewWeightedScorer(prefixScorer, 50))
 			assert.NoError(t, err, "SchedulerProfile AddPlugins returned unexpected error")
 
 			decodeSchedulerProfile := framework.NewSchedulerProfile().
-				WithFilters(filter.NewDecodeFilter()).
+				WithFilters(filter.NewDecode()).
 				WithScorers(framework.NewWeightedScorer(scorer.NewLoadAwareScorer(ctx, scorer.QueueThresholdDefault), 1)).
 				WithPicker(picker.NewMaxScorePicker(picker.DefaultMaxNumOfEndpoints))
 			err = decodeSchedulerProfile.AddPlugins(framework.NewWeightedScorer(prefixScorer, 0))