Update config to use shape and domain instead of strategy

Signed-off-by: Loic Marchal <lmarchal@redhat.com>

Author: loicmarchal

pkg/epp/framework/plugins/flowcontrol/usagelimits/priorityholdback/README.md

@@ -12,21 +12,29 @@ Each active priority level receives an admission ceiling in [0.0, 1.0]. During e
 
 Higher-priority traffic continues to flow until saturation reaches its own (higher) ceiling, providing quality-of-service differentiation under load.
 
-## Strategies
+## Configuration
 
-Two strategies are available for computing per-priority ceilings. Both produce `maxCeiling` for the highest priority and `minCeiling` for the lowest.
+Behavior is configured via two independent parameters: `shape` and `domain`. The resulting ceilings always range from `maxCeiling` for the highest priority to `minCeiling` for the lowest.
 
-### `stepwise-spread`
+### `shape`
 
-Distributes ceilings in equal steps by rank, ignoring numerical priority values.
+The interpolation curve used to distribute ceilings across the range. Currently only `"linear"` is supported.
+
+### `domain`
+
+How priority levels are mapped to positions in the ceiling range.
+
+#### `rank` (default)
+
+Distributes ceilings in equal steps by ordinal rank, ignoring numerical priority values. Ceilings are evenly spaced across `[minCeiling, maxCeiling]`.
 
     c_i = maxCeiling - i * (maxCeiling - minCeiling) / (N - 1)
 
 Where `i` is the index in descending priority order (0 = highest) and `N` is the count of active priorities.
 
 Use when priorities represent ordinal categories (e.g., "critical", "normal", "batch") where the numerical values are arbitrary labels.
 
-### `linear-proportional`
+#### `value`
 
 Scales ceilings proportionally to the numerical priority value within the observed active range.
 
@@ -37,7 +45,8 @@ Use when the numerical spacing between priority values carries meaning and prior
 
 **Parameters:**
 
-- `strategy` (string, required, no default): Gating algorithm: `"stepwise-spread"` or `"linear-proportional"`.
+- `shape` (string, optional, default: `"linear"`): Interpolation curve. Currently only `"linear"` is supported.
+- `domain` (string, optional, default: `"rank"`): Priority mapping: `"rank"` or `"value"`.
 - `minCeiling` (float64, required, no default): Ceiling for the lowest priority. Must be in `[0.0, 1.0)`.
 - `maxCeiling` (float64, optional, default: `1.0`): Ceiling for the highest priority. Must be in `(0.0, 1.0]`.
 
@@ -49,7 +58,8 @@ plugins:
   - type: priority-holdback-policy
     name: my-holdback-policy
     parameters:
-      strategy: stepwise-spread
+      shape: linear
+      domain: rank
       minCeiling: 0.4
       maxCeiling: 0.9
 flowControl:

pkg/epp/framework/plugins/flowcontrol/usagelimits/priorityholdback/config.go

@@ -23,29 +23,40 @@ import (
 	"k8s.io/utils/ptr"
 )
 
-// strategy constants define the supported gating strategies.
+// shape constants define the interpolation curve applied across the ceiling range.
+// Only "linear" is supported; additional shapes (sigmoid, exponential, step, etc.) may be added.
 const (
-	// strategyStepwiseSpread divides the [minCeiling, maxCeiling] range into equal steps based on
-	// the count of active priorities, ignoring their absolute numerical difference.
-	strategyStepwiseSpread = "stepwise-spread"
+	shapeLinear = "linear"
+)
 
-	// strategyLinearProportional scales ceilings linearly based on numerical priority values
-	// relative to the observed active range.
-	strategyLinearProportional = "linear-proportional"
+// domain constants define how priority levels are mapped to positions in the ceiling range.
+const (
+	// domainRank maps by ordinal rank, ignoring numerical priority values.
+	domainRank = "rank"
+	// domainValue maps proportionally to numerical priority values.
+	domainValue = "value"
 )
 
 const (
-	// defaultMaxCeiling allows the highest priority to use full capacity.
+	defaultShape              = shapeLinear
+	defaultDomain             = domainRank
 	defaultMaxCeiling float64 = 1.0
 )
 
 // apiConfig represents the external configuration schema for the priority holdback policy.
 // It is designed to be deserialized from JSON via the plugin's raw parameters.
 type apiConfig struct {
-	// Strategy selects the gating algorithm used to compute per-priority admission ceilings.
+	// Shape selects the interpolation curve used to distribute ceilings across the range.
+	//
+	// Optional, defaults to "linear". Currently only "linear" is supported.
+	Shape *string `json:"shape,omitempty"`
+
+	// Domain selects how priority levels are mapped to positions in the ceiling range.
+	//   - "rank": equal spacing by ordinal rank, ignoring numerical values.
+	//   - "value": spacing proportional to numerical priority differences.
 	//
-	// Required. Valid values: "stepwise-spread", "linear-proportional".
-	Strategy *string `json:"strategy"`
+	// Optional, defaults to "rank".
+	Domain *string `json:"domain,omitempty"`
 
 	// MinCeiling is the admission ceiling assigned to the lowest-priority traffic.
 	// Determines how aggressively the lowest priority is gated as saturation rises.
@@ -62,7 +73,8 @@ type apiConfig struct {
 
 // config is the internal, fully-validated configuration used by the policy.
 type config struct {
-	strategy   string
+	shape      string
+	domain     string
 	minCeiling float64
 	maxCeiling float64
 }
@@ -87,28 +99,29 @@ func buildConfig(apiCfg *apiConfig) (*config, error) {
 	}
 
 	return &config{
-		strategy:   *safeCfg.Strategy,
+		shape:      *safeCfg.Shape,
+		domain:     *safeCfg.Domain,
 		minCeiling: *safeCfg.MinCeiling,
 		maxCeiling: *safeCfg.MaxCeiling,
 	}, nil
 }
 
 // checkRequired verifies that mandatory fields are present before defaulting.
 func checkRequired(cfg *apiConfig) error {
-	var errs []error
-
-	if cfg.Strategy == nil {
-		errs = append(errs, fmt.Errorf("strategy is required"))
-	}
 	if cfg.MinCeiling == nil {
-		errs = append(errs, fmt.Errorf("minCeiling is required"))
+		return fmt.Errorf("minCeiling is required")
 	}
-
-	return errors.Join(errs...)
+	return nil
 }
 
 // applyDefaults populates unset optional fields with their standard defaults.
 func applyDefaults(cfg *apiConfig) {
+	if cfg.Shape == nil {
+		cfg.Shape = ptr.To(defaultShape)
+	}
+	if cfg.Domain == nil {
+		cfg.Domain = ptr.To(defaultDomain)
+	}
 	if cfg.MaxCeiling == nil {
 		cfg.MaxCeiling = ptr.To(defaultMaxCeiling)
 	}
@@ -119,12 +132,21 @@ func applyDefaults(cfg *apiConfig) {
 func validateConfig(cfg *apiConfig) error {
 	var errs []error
 
-	if cfg.Strategy != nil {
-		switch *cfg.Strategy {
-		case strategyStepwiseSpread, strategyLinearProportional:
+	if cfg.Shape != nil {
+		switch *cfg.Shape {
+		case shapeLinear:
+		default:
+			errs = append(errs, fmt.Errorf("unsupported shape %q, must be %q",
+				*cfg.Shape, shapeLinear))
+		}
+	}
+
+	if cfg.Domain != nil {
+		switch *cfg.Domain {
+		case domainRank, domainValue:
 		default:
-			errs = append(errs, fmt.Errorf("unsupported strategy %q, must be one of: %q, %q",
-				*cfg.Strategy, strategyStepwiseSpread, strategyLinearProportional))
+			errs = append(errs, fmt.Errorf("unsupported domain %q, must be one of: %q, %q",
+				*cfg.Domain, domainRank, domainValue))
 		}
 	}
 

pkg/epp/framework/plugins/flowcontrol/usagelimits/priorityholdback/priority_holdback.go

@@ -2,9 +2,9 @@
 // ceilings per priority level. Lower-priority traffic is gated at lower saturation thresholds,
 // reserving capacity for higher-priority work as the pool approaches saturation.
 //
-// Two strategies are supported:
-//   - "stepwise-spread": equal ceiling spacing by rank, ignoring numerical priority values.
-//   - "linear-proportional": ceiling spacing proportional to numerical priority differences.
+// Behavior is configured via two independent parameters:
+//   - shape: the interpolation curve (currently "linear"; future: sigmoid, exponential, etc.).
+//   - domain: how priorities map to positions ("rank" for ordinal, "value" for proportional).
 package priorityholdback
 
 import (
@@ -47,10 +47,10 @@ var _ flowcontrol.UsageLimitPolicy = &priorityHoldbackPolicy{}
 
 func newPriorityHoldbackPolicy(cfg config) *priorityHoldbackPolicy {
 	var fn func(cMin, cMax float64, priorities []int) (ceilings []float64)
-	switch cfg.strategy {
-	case strategyStepwiseSpread:
+	switch cfg.domain {
+	case domainRank:
 		fn = computeLimitStepwiseSpread
-	case strategyLinearProportional:
+	case domainValue:
 		fn = computeLimitLinearProportional
 	}
 	return &priorityHoldbackPolicy{