Add Range Validation core logic

Author: AdarshK15

community/modules/scheduler/schedmd-slurm-gcp-v6-controller/metadata.yaml

@@ -21,8 +21,13 @@ spec:
     - storage.googleapis.com
 ghpc:
   validators:
+  - validator: range
+    inputs:
+      vars: [static_ips]
+      max: 1
+    error_message: "The Slurm modules supports 0 or 1 static IPs on controller instance."
   - validator: regex
     inputs:
       vars: [slurm_cluster_name]
       pattern: "^[a-z](?:[a-z0-9]{0,9})$"
-    error_message: "'slurm_cluster_name' must contain only lowercase letters and numbers, start with a letter, and be 1-10 characters long."
+    error_message: "'slurm_cluster_name' must contain abc only lowercase letters and numbers, start with a letter, and be 1-10 characters long."

pkg/validators/metadata_validator_helpers.go

@@ -123,6 +123,24 @@ type Target struct {
 	IsBlueprint bool // true if came from blueprint vars, false if module.settings
 }
 
+// parseIntInput retrieves an integer value from a map by key.
+// If the key is missing, it returns the defaultVal.
+func parseIntInput(inputs map[string]interface{}, key string, defaultVal int) (int, error) {
+	v, ok := inputs[key]
+	if !ok {
+		return defaultVal, nil
+	}
+
+	switch t := v.(type) {
+	case int:
+		return t, nil
+	case float64:
+		return int(t), nil
+	default:
+		return 0, fmt.Errorf("'%s' must be an integer, not %T", key, v)
+	}
+}
+
 // processModuleSettings processes a list of names interpreted as module settings.
 func processModuleSettings(bp config.Blueprint, mod config.Module, group config.Group, modIdx int, list []string, optional bool, handler func(Target) error) error {
 	for _, s := range list {

pkg/validators/metadata_validators.go

@@ -13,6 +13,7 @@ package validators
 
 import (
 	"fmt"
+	"math"
 	"regexp"
 	"strings"
 
@@ -192,3 +193,79 @@ func (v *AllowedEnumValidator) Validate(
 		return v.checkValues(t.Values, t.Path, allowedSet, allowedList, caseSensitive, allowNull, rule.ErrorMessage)
 	})
 }
+
+// RangeValidator implements the Validator interface for 'range' type.
+type RangeValidator struct{}
+
+// Validate checks if the variables specified in the rule match the provided range pattern.
+// This function focuses on the predicate and uses IterateRuleTargets from targets.go to resolve targets.
+func (r *RangeValidator) Validate(
+	bp config.Blueprint,
+	mod config.Module,
+	rule modulereader.ValidationRule,
+	group config.Group,
+	modIdx int) error {
+
+	modPath := config.Root.Groups.At(bp.GroupIndex(group.Name)).Modules.At(modIdx).Source
+	// Extract min
+
+	min, err := parseIntInput(rule.Inputs, "min", math.MinInt)
+	if err != nil {
+		return config.BpError{
+			Err: fmt.Errorf(
+				"validation rule for module %q: %v", mod.ID, err),
+			Path: modPath,
+		}
+	}
+	// Extract max
+	max, err := parseIntInput(rule.Inputs, "max", math.MaxInt)
+	if err != nil {
+		return config.BpError{
+			Err: fmt.Errorf(
+				"validation rule for module %q: %v", mod.ID, err),
+			Path: modPath,
+		}
+	}
+
+	// helper: validate flattened cty.Values against range, returning first error
+	validateValues := func(values []cty.Value, path config.Path) error {
+		for _, val := range values {
+			if val.IsNull() || !val.IsKnown() {
+				continue
+			}
+			var checkValue int
+			var isList bool
+			if val.Type().IsListType() {
+				checkValue = val.LengthInt()
+				isList = true
+			} else if val.Type() == cty.Number {
+				f, _ := val.AsBigFloat().Float64()
+				checkValue = int(f)
+			} else {
+				return config.BpError{
+					Err:  fmt.Errorf("range validator only supports numbers or lists, not %s", val.Type().FriendlyName()),
+					Path: path,
+				}
+			}
+			effectiveMin := min
+			if isList {
+				effectiveMin = 0 // Default min is 0 for lists if not specified
+			}
+
+			if checkValue < effectiveMin || checkValue > max {
+				msg := rule.ErrorMessage
+				if msg == "" {
+					msg = fmt.Sprintf("value %d is out of range [%d, %d]", checkValue, effectiveMin, max)
+				}
+				return config.BpError{Err: fmt.Errorf("error: %s", msg), Path: path}
+			}
+		}
+		return nil
+	}
+
+	// iterate targets using shared logic
+	err = IterateRuleTargets(bp, mod, rule, group, modIdx, func(t Target) error {
+		return validateValues(t.Values, t.Path)
+	})
+	return err
+}

pkg/validators/registry.go

@@ -16,6 +16,7 @@ package validators
 
 // Registry maps validation type strings to their corresponding validator implementation.
 var Registry = map[string]RuleValidator{
-	"regex":        &RegexValidator{},
+	"regex": &RegexValidator{},
 	"allowed_enum": &AllowedEnumValidator{},
+	"range": &RangeValidator{},
 }