Revert jsonschema library to v0.1.2 to maintain old behavior

Author: openhands-agent

go.mod

@@ -1,6 +1,6 @@
 module github.com/fairwindsops/polaris
 
-go 1.19
+go 1.24.0
 
 require (
 	github.com/AlecAivazis/survey/v2 v2.3.7
@@ -9,7 +9,7 @@ require (
 	github.com/fatih/color v1.18.0
 	github.com/gorilla/mux v1.8.1
 	github.com/pkg/errors v0.9.1
-	github.com/qri-io/jsonschema v0.2.1
+	github.com/qri-io/jsonschema v0.1.2
 	github.com/sirupsen/logrus v1.9.3
 	github.com/spf13/cobra v1.9.1
 	github.com/stretchr/testify v1.10.0

pkg/config/checks/hostPortSet.yaml

@@ -8,16 +8,11 @@ schema:
   required:
   properties:
     ports:
-      oneOf:
-        - type: "null"
-        - type: "array"
-          items:
-            not:
-              properties:
-                hostPort:
-                  not:
-                    enum: [0, null]
-              required: ["hostPort"]
+      type: array
+      items:
+        properties:
+          hostPort:
+            const: 0
 mutations:
   - op: remove
     path: /ports/*/hostPort

pkg/config/schema.go

@@ -16,15 +16,13 @@ package config
 
 import (
 	"bytes"
-	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
 	"strings"
 	"text/template"
 
-	jptr "github.com/qri-io/jsonpointer"
 	"github.com/qri-io/jsonschema"
 	"github.com/thoas/go-funk"
 	corev1 "k8s.io/api/core/v1"
@@ -74,11 +72,10 @@ type SchemaCheck struct {
 	SchemaTarget            TargetKind                        `yaml:"schemaTarget" json:"schemaTarget"`
 	Schema                  map[string]interface{}            `yaml:"schema" json:"schema"`
 	SchemaString            string                            `yaml:"schemaString" json:"schemaString"`
-	JSONSchema              string                            `yaml:"jsonSchema" json:"jsonSchema"`
-	Validator               *jsonschema.Schema                `yaml:"-" json:"-"`
+	Validator               jsonschema.RootSchema             `yaml:"-" json:"-"`
 	AdditionalSchemas       map[string]map[string]interface{} `yaml:"additionalSchemas" json:"additionalSchemas"`
 	AdditionalSchemaStrings map[string]string                 `yaml:"additionalSchemaStrings" json:"additionalSchemaStrings"`
-	AdditionalValidators    map[string]*jsonschema.Schema     `yaml:"-" json:"-"`
+	AdditionalValidators    map[string]jsonschema.RootSchema  `yaml:"-" json:"-"`
 	Mutations               []Mutation                        `yaml:"mutations" json:"mutations"`
 }
 
@@ -112,114 +109,59 @@ func ParseCheck(id string, rawBytes []byte) (SchemaCheck, error) {
 }
 
 func init() {
-	jsonschema.RegisterKeyword("resourceMinimum", newResourceMinimum)
-	jsonschema.RegisterKeyword("resourceMaximum", newResourceMaximum)
+	jsonschema.RegisterValidator("resourceMinimum", newResourceMinimum)
+	jsonschema.RegisterValidator("resourceMaximum", newResourceMaximum)
 }
 
 type includeExcludeList struct {
 	Include []string `yaml:"include"`
 	Exclude []string `yaml:"exclude"`
 }
 
-func newResourceMinimum() jsonschema.Keyword {
+func newResourceMinimum() jsonschema.Validator {
 	return new(resourceMinimum)
 }
 
-func newResourceMaximum() jsonschema.Keyword {
+func newResourceMaximum() jsonschema.Validator {
 	return new(resourceMaximum)
 }
 
-// ValidateKeyword checks that a specified quanitity is not less than the minimum
-func (min resourceMinimum) ValidateKeyword(ctx context.Context, currentState *jsonschema.ValidationState, data interface{}) {
-	path := ""
-	if currentState.InstanceLocation != nil {
-		path = currentState.InstanceLocation.String()
-	}
+// Validate checks that a specified quanitity is not less than the minimum
+func (min resourceMinimum) Validate(path string, data interface{}, errs *[]jsonschema.ValError) {
 	err := validateRange(path, string(min), data, true)
 	if err != nil {
-		for _, e := range *err {
-			currentState.AddError(e.InvalidValue, e.Message)
-		}
-	}
-}
-
-// Register implements jsonschema.Keyword
-func (min resourceMinimum) Register(uri string, registry *jsonschema.SchemaRegistry) {}
-
-// Resolve implements jsonschema.Keyword
-func (min resourceMinimum) Resolve(pointer jptr.Pointer, uri string) *jsonschema.Schema {
-	return nil
-}
-
-// UnmarshalJSON implements json.Unmarshaler
-func (min *resourceMinimum) UnmarshalJSON(data []byte) error {
-	var s string
-	if err := json.Unmarshal(data, &s); err != nil {
-		return err
+		*errs = append(*errs, *err...)
 	}
-	*min = resourceMinimum(s)
-	return nil
 }
 
-// ValidateKeyword checks that a specified quanitity is not greater than the maximum
-func (max resourceMaximum) ValidateKeyword(ctx context.Context, currentState *jsonschema.ValidationState, data interface{}) {
-	path := ""
-	if currentState.InstanceLocation != nil {
-		path = currentState.InstanceLocation.String()
-	}
+// Validate checks that a specified quanitity is not greater than the maximum
+func (max resourceMaximum) Validate(path string, data interface{}, errs *[]jsonschema.ValError) {
 	err := validateRange(path, string(max), data, false)
 	if err != nil {
-		for _, e := range *err {
-			currentState.AddError(e.InvalidValue, e.Message)
-		}
+		*errs = append(*errs, *err...)
 	}
 }
 
-// Register implements jsonschema.Keyword
-func (max resourceMaximum) Register(uri string, registry *jsonschema.SchemaRegistry) {}
-
-// Resolve implements jsonschema.Keyword
-func (max resourceMaximum) Resolve(pointer jptr.Pointer, uri string) *jsonschema.Schema {
-	return nil
-}
-
-// UnmarshalJSON implements json.Unmarshaler
-func (max *resourceMaximum) UnmarshalJSON(data []byte) error {
-	var s string
-	if err := json.Unmarshal(data, &s); err != nil {
-		return err
-	}
-	*max = resourceMaximum(s)
-	return nil
-}
-
-// ValError is a custom type to maintain compatibility with the old API
-type ValError struct {
-	PropertyPath string
-	InvalidValue interface{}
-	Message      string
-}
-
-func parseQuantity(i interface{}) (resource.Quantity, *[]ValError) {
+func parseQuantity(i interface{}) (resource.Quantity, *[]jsonschema.ValError) {
 	if resNum, ok := i.(float64); ok {
 		i = fmt.Sprintf("%f", resNum)
 	}
 	resStr, ok := i.(string)
 	if !ok {
-		return resource.Quantity{}, &[]ValError{
+		return resource.Quantity{}, &[]jsonschema.ValError{
 			{Message: fmt.Sprintf("Resource quantity %v is not a string", i)},
 		}
 	}
 	q, err := resource.ParseQuantity(resStr)
 	if err != nil {
-		return resource.Quantity{}, &[]ValError{
+		return resource.Quantity{}, &[]jsonschema.ValError{
 			{Message: fmt.Sprintf("Could not parse resource quantity: %s", resStr)},
 		}
 	}
 	return q, nil
 }
 
-func validateRange(path string, limit interface{}, data interface{}, isMinimum bool) *[]ValError {
+func validateRange(path string, limit interface{}, data interface{}, isMinimum bool) *[]jsonschema.ValError {
 	limitQuantity, err := parseQuantity(limit)
 	if err != nil {
 		return err
@@ -228,31 +170,17 @@ func validateRange(path string, limit interface{}, data interface{}, isMinimum b
 	if err != nil {
 		return err
 	}
-	
+	cmp := limitQuantity.Cmp(actualQuantity)
 	if isMinimum {
-		// For minimum, the actual quantity should be >= limit
-		// If actual < limit, then it's an error
-		// actualQuantity.Cmp(limitQuantity) returns -1 if actual < limit
-		if actualQuantity.Cmp(limitQuantity) == -1 {
-			return &[]ValError{
-				{
-					PropertyPath: path,
-					InvalidValue: data,
-					Message:      fmt.Sprintf("%s quantity %v is less than minimum %v", path, actualQuantity, limitQuantity),
-				},
+		if cmp == 1 {
+			return &[]jsonschema.ValError{
+				{Message: fmt.Sprintf("%s quantity %v is > %v", path, actualQuantity, limitQuantity)},
 			}
 		}
 	} else {
-		// For maximum, the actual quantity should be <= limit
-		// If actual > limit, then it's an error
-		// actualQuantity.Cmp(limitQuantity) returns 1 if actual > limit
-		if actualQuantity.Cmp(limitQuantity) == 1 {
-			return &[]ValError{
-				{
-					PropertyPath: path,
-					InvalidValue: data,
-					Message:      fmt.Sprintf("%s quantity %v is greater than maximum %v", path, actualQuantity, limitQuantity),
-				},
+		if cmp == -1 {
+			return &[]jsonschema.ValError{
+				{Message: fmt.Sprintf("%s quantity %v is < %v", path, actualQuantity, limitQuantity)},
 			}
 		}
 	}
@@ -262,9 +190,7 @@ func validateRange(path string, limit interface{}, data interface{}, isMinimum b
 // Initialize sets up the schema
 func (check *SchemaCheck) Initialize(id string) error {
 	check.ID = id
-	if check.JSONSchema != "" {
-		check.SchemaString = check.JSONSchema
-	} else if check.SchemaString == "" {
+	if check.SchemaString == "" {
 		jsonBytes, err := json.Marshal(check.Schema)
 		if err != nil {
 			return err
@@ -325,74 +251,50 @@ func (check SchemaCheck) TemplateForResource(res interface{}) (*SchemaCheck, err
 		}
 	}
 
-	newCheck.AdditionalValidators = map[string]*jsonschema.Schema{}
+	newCheck.AdditionalValidators = map[string]jsonschema.RootSchema{}
 	for kind, schemaStr := range newCheck.AdditionalSchemaStrings {
-		var schemaMap map[string]interface{}
-		err := UnmarshalYAMLOrJSON([]byte(schemaStr), &schemaMap)
-		if err != nil {
-			return nil, err
-		}
-		jsonBytes, err := json.Marshal(schemaMap)
+		val := jsonschema.RootSchema{}
+		err := UnmarshalYAMLOrJSON([]byte(schemaStr), &val)
 		if err != nil {
 			return nil, err
 		}
-		val := jsonschema.Must(string(jsonBytes))
 		newCheck.AdditionalValidators[kind] = val
 	}
-	if newCheck.SchemaString != "" {
-		var schemaMap map[string]interface{}
-		err := UnmarshalYAMLOrJSON([]byte(newCheck.SchemaString), &schemaMap)
-		if err != nil {
-			return nil, err
-		}
-		jsonBytes, err := json.Marshal(schemaMap)
-		if err != nil {
-			return nil, err
-		}
-		
-		// Custom keywords are now registered globally in init()
-		
-
-		newCheck.Validator = jsonschema.Must(string(jsonBytes))
+	err := UnmarshalYAMLOrJSON([]byte(newCheck.SchemaString), &newCheck.Validator)
+	if err != nil {
+		return nil, err
 	}
-	return &newCheck, nil
+	return &newCheck, err
 }
 
 // CheckPodSpec checks a pod spec against the schema
-func (check SchemaCheck) CheckPodSpec(pod *corev1.PodSpec) (bool, []jsonschema.KeyError, error) {
+func (check SchemaCheck) CheckPodSpec(pod *corev1.PodSpec) (bool, []jsonschema.ValError, error) {
 	return check.CheckObject(pod)
 }
 
 // CheckPodTemplate checks a pod template against the schema
-func (check SchemaCheck) CheckPodTemplate(podTemplate interface{}) (bool, []jsonschema.KeyError, error) {
+func (check SchemaCheck) CheckPodTemplate(podTemplate interface{}) (bool, []jsonschema.ValError, error) {
 	return check.CheckObject(podTemplate)
 }
 
 // CheckController checks a controler's spec against the schema
-func (check SchemaCheck) CheckController(bytes []byte) (bool, []jsonschema.KeyError, error) {
-	if check.Validator == nil {
-		return true, nil, nil
-	}
-	errs, err := check.Validator.ValidateBytes(context.Background(), bytes)
+func (check SchemaCheck) CheckController(bytes []byte) (bool, []jsonschema.ValError, error) {
+	errs, err := check.Validator.ValidateBytes(bytes)
 	return len(errs) == 0, errs, err
 }
 
 // CheckContainer checks a container spec against the schema
-func (check SchemaCheck) CheckContainer(container *corev1.Container) (bool, []jsonschema.KeyError, error) {
+func (check SchemaCheck) CheckContainer(container *corev1.Container) (bool, []jsonschema.ValError, error) {
 	return check.CheckObject(container)
 }
 
 // CheckObject checks arbitrary data against the schema
-func (check SchemaCheck) CheckObject(obj interface{}) (bool, []jsonschema.KeyError, error) {
+func (check SchemaCheck) CheckObject(obj interface{}) (bool, []jsonschema.ValError, error) {
 	bytes, err := json.Marshal(obj)
 	if err != nil {
 		return false, nil, err
 	}
-	if check.Validator == nil {
-		return true, nil, nil
-	}
-
-	errs, err := check.Validator.ValidateBytes(context.Background(), bytes)
+	errs, err := check.Validator.ValidateBytes(bytes)
 	return len(errs) == 0, errs, err
 }
 
@@ -407,7 +309,7 @@ func (check SchemaCheck) CheckAdditionalObjects(groupkind string, objects []inte
 		if err != nil {
 			return false, err
 		}
-		errs, err := val.ValidateBytes(context.Background(), bytes)
+		errs, err := val.ValidateBytes(bytes)
 		if err != nil {
 			return false, err
 		}
@@ -465,4 +367,4 @@ func (check SchemaCheck) IsActionable(target TargetKind, kind string, isInit boo
 		}
 	}
 	return true
-}
+}

pkg/validator/custom.go

@@ -6,7 +6,7 @@ import (
 	"github.com/qri-io/jsonschema"
 )
 
-type validatorFunction func(test schemaTestCase) (bool, []jsonschema.KeyError, error)
+type validatorFunction func(test schemaTestCase) (bool, []jsonschema.ValError, error)
 
 var validatorMapper = map[string]validatorFunction{}
 var lock = &sync.Mutex{}

pkg/validator/pdb_hpa_validator.go

@@ -19,7 +19,7 @@ func init() {
 	registerCustomChecks("pdbMinAvailableGreaterThanHPAMinReplicas", pdbMinAvailableGreaterThanHPAMinReplicas)
 }
 
-func pdbMinAvailableGreaterThanHPAMinReplicas(test schemaTestCase) (bool, []jsonschema.KeyError, error) {
+func pdbMinAvailableGreaterThanHPAMinReplicas(test schemaTestCase) (bool, []jsonschema.ValError, error) {
 	if test.ResourceProvider == nil {
 		return true, nil, nil
 	}
@@ -70,7 +70,7 @@ func pdbMinAvailableGreaterThanHPAMinReplicas(test schemaTestCase) (bool, []json
 		}
 
 		if attachedHPA.Spec.MinReplicas != nil && pdbMinAvailable > int(*attachedHPA.Spec.MinReplicas) {
-			return false, []jsonschema.KeyError{
+			return false, []jsonschema.ValError{
 				{
 					PropertyPath: "spec.minAvailable",
 					InvalidValue: pdbMinAvailable,

pkg/validator/schema.go

@@ -133,7 +133,7 @@ func getTemplateInput(test schemaTestCase) (map[string]interface{}, error) {
 	return templateInput, nil
 }
 
-func makeResult(conf *config.Configuration, check *config.SchemaCheck, passes bool, issues []jsonschema.KeyError) ResultMessage {
+func makeResult(conf *config.Configuration, check *config.SchemaCheck, passes bool, issues []jsonschema.ValError) ResultMessage {
 	details := []string{}
 	for _, issue := range issues {
 		details = append(details, issue.Message)
@@ -394,7 +394,7 @@ func applySchemaCheck(conf *config.Configuration, checkID string, test schemaTes
 	} else if validatorMapper[checkID] != nil {
 		passes, issues, err = validatorMapper[checkID](test)
 	} else {
-		passes, issues, err = true, []jsonschema.KeyError{}, nil
+		passes, issues, err = true, []jsonschema.ValError{}, nil
 	}
 	if err != nil {
 		return nil, err