wip parser for auth params

Signed-off-by: Jan Wozniak <[email protected]>

pkg/scalers/authentication/authentication_types.go

@@ -61,6 +61,10 @@ type AuthMeta struct {
 	CustomAuthValue  string
 }
 
+type AuthConfig struct {
+	AuthModes []string `keda:"authModes, parsingOrder=triggerMetadata, enum=apiKey;basic;tls;bearer;custom;oauth, exclusive=bearer;basic;oauth"`
+}
+
 type HTTPTransport struct {
 	MaxIdleConnDuration time.Duration
 	ReadTimeout         time.Duration

pkg/scalers/scalersconfig/typed_config.go

@@ -56,6 +56,8 @@ const (
 	defaultTag      = "default"
 	parsingOrderTag = "parsingOrder"
 	nameTag         = "name"
+	enumTag         = "enum"
+	exclusiveTag    = "exclusive"
 )
 
 // Params is a struct that represents the parameter list that can be used in the keda tag
@@ -65,6 +67,8 @@ type Params struct {
 	ParsingOrder []ParsingOrder
 	Default      string
 	Deprecated   string
+	Enum         []string
+	Exclusive    []string
 }
 
 // IsDeprecated is a function that returns true if the parameter is deprecated
@@ -127,6 +131,36 @@ func (sc *ScalerConfig) setValue(field reflect.Value, params Params) error {
 	if !exists && !(params.Optional || params.IsDeprecated()) {
 		return fmt.Errorf("missing required parameter %q in %v", params.Name, params.ParsingOrder)
 	}
+	if params.Enum != nil {
+		found := false
+		for _, e := range params.Enum {
+			if e == valFromConfig {
+				found = true
+				break
+			}
+		}
+		if !found {
+			return fmt.Errorf("parameter %q value %q must be one of %v", params.Name, valFromConfig, params.Enum)
+		}
+	}
+	if params.Exclusive != nil {
+		exclusiveMap := make(map[string]bool)
+		for _, e := range params.Exclusive {
+			exclusiveMap[e] = true
+		}
+		split := strings.Split(valFromConfig, elemSeparator)
+		exclusiveCount := 0
+		for _, s := range split {
+			s := strings.TrimSpace(s)
+			if exclusiveMap[s] {
+				exclusiveCount++
+			}
+		}
+		if exclusiveCount > 1 {
+			return fmt.Errorf("parameter %q value %q must contain only one of %v", params.Name, valFromConfig, params.Exclusive)
+		}
+	}
+
 	if err := setConfigValueHelper(valFromConfig, field); err != nil {
 		return fmt.Errorf("unable to set param %q value %q: %w", params.Name, valFromConfig, err)
 	}
@@ -250,6 +284,14 @@ func paramsFromTag(tag string, field reflect.StructField) (Params, error) {
 			if len(tsplit) > 1 {
 				params.Default = strings.TrimSpace(tsplit[1])
 			}
+		case enumTag:
+			if len(tsplit) > 1 {
+				params.Enum = strings.Split(tsplit[1], tagValueSeparator)
+			}
+		case exclusiveTag:
+			if len(tsplit) > 1 {
+				params.Exclusive = strings.Split(tsplit[1], tagValueSeparator)
+			}
 		default:
 			return params, fmt.Errorf("unknown tag %s: %s", tsplit[0], tag)
 		}

pkg/scalers/scalersconfig/typed_config_test.go

@@ -229,3 +229,60 @@ func TestSlice(t *testing.T) {
 	Expect(ts.SliceVal[1]).To(Equal(2))
 	Expect(ts.SliceVal[2]).To(Equal(3))
 }
+
+func TestEnum(t *testing.T) {
+	RegisterTestingT(t)
+
+	sc := &ScalerConfig{
+		TriggerMetadata: map[string]string{
+			"enumVal": "value1",
+		},
+	}
+
+	type testStruct struct {
+		EnumVal string `keda:"name=enumVal, parsingOrder=triggerMetadata, enum=value1;value2"`
+	}
+
+	ts := testStruct{}
+	err := sc.TypedConfig(&ts)
+	Expect(err).To(BeNil())
+	Expect(ts.EnumVal).To(Equal("value1"))
+
+	sc2 := &ScalerConfig{
+		TriggerMetadata: map[string]string{
+			"enumVal": "value3",
+		},
+	}
+
+	ts2 := testStruct{}
+	err = sc2.TypedConfig(&ts2)
+	Expect(err).To(MatchError(`parameter "enumVal" value "value3" must be one of [value1 value2]`))
+}
+
+func TestExclusive(t *testing.T) {
+	RegisterTestingT(t)
+
+	type testStruct struct {
+		IntVal []int `keda:"name=intVal,    parsingOrder=triggerMetadata, exclusive=1;4;5"`
+	}
+
+	sc := &ScalerConfig{
+		TriggerMetadata: map[string]string{
+			"intVal": "1,2,3",
+		},
+	}
+
+	ts := testStruct{}
+	err := sc.TypedConfig(&ts)
+	Expect(err).To(BeNil())
+
+	sc2 := &ScalerConfig{
+		TriggerMetadata: map[string]string{
+			"intVal": "1,4",
+		},
+	}
+
+	ts2 := testStruct{}
+	err = sc2.TypedConfig(&ts2)
+	Expect(err).To(MatchError(`parameter "intVal" value "1,4" must contain only one of [1 4 5]`))
+}