Allow configuration of validators in schemacheck

Author: JoelSpeed

example/.codegen.yaml

@@ -4,6 +4,10 @@ deepcopy:
   disabled: false
   headerFilePath: ../hack/empty.txt
   outputFileBaseName: zz_generated.deepcopy
+schemacheck:
+  disabled: false
+  enabledValidators: []
+  disabledValidators: []
 schemapatch:
   disabled: false
   requiredFeatureSets:

tools/codegen/cmd/schemacheck.go

@@ -2,12 +2,19 @@ package main
 
 import (
 	"fmt"
+	"strings"
 
 	"github.com/openshift/api/tools/codegen/pkg/generation"
 	"github.com/openshift/api/tools/codegen/pkg/schemacheck"
+	"github.com/openshift/crd-schema-checker/pkg/cmd/options"
 	"github.com/spf13/cobra"
 )
 
+var (
+	defaultComparisonConfig = options.NewComparatorOptions()
+	comparisonBase          = "master"
+)
+
 // schemacheckCmd represents the schemacheck command
 var schemacheckCmd = &cobra.Command{
 	Use:   "schemacheck",
@@ -29,9 +36,18 @@ var schemacheckCmd = &cobra.Command{
 
 func init() {
 	rootCmd.AddCommand(schemacheckCmd)
+
+	knownComparators := strings.Join(defaultComparisonConfig.KnownComparators, ", ")
+	rootCmd.PersistentFlags().StringSliceVar(&defaultComparisonConfig.DisabledComparators, "schemacheck:disabled-validators", defaultComparisonConfig.DisabledComparators, fmt.Sprintf("list of comparators that must be disabled. Available comparators: %s", knownComparators))
+	rootCmd.PersistentFlags().StringSliceVar(&defaultComparisonConfig.EnabledComparators, "schemacheck:enabled-validators", defaultComparisonConfig.EnabledComparators, fmt.Sprintf("list of comparators that must be enabled. Available comparators: %s", knownComparators))
+	rootCmd.PersistentFlags().StringVar(&comparisonBase, "schemacheck:comparison-base", comparisonBase, "base branch/commit to compare against")
 }
 
 // newSchemaCheckGenerator builds a new schemacheck generator.
 func newSchemaCheckGenerator() generation.Generator {
-	return schemacheck.NewGenerator(schemacheck.Options{})
+	return schemacheck.NewGenerator(schemacheck.Options{
+		EnabledComparators:  defaultComparisonConfig.EnabledComparators,
+		DisabledComparators: defaultComparisonConfig.DisabledComparators,
+		ComparisonBase:      comparisonBase,
+	})
 }

tools/codegen/pkg/generation/types.go

@@ -67,6 +67,14 @@ type SchemaCheckConfig struct {
 	// Disabled determines whether the schemacheck generator should be run or not.
 	// This generator is enabled by default so this field defaults to false.
 	Disabled bool `json:"disabled,omitempty"`
+
+	// EnabledValidators is a list of the validators that should be enabled.
+	// If this is empty, the default validators are enabled.
+	EnabledValidators []string `json:"enabledValidators,omitempty"`
+
+	// DisabledValidators is a list of the validators that should be disabled.
+	// If this is empty, no default validators are disabled.
+	DisabledValidators []string `json:"disabledValidators,omitempty"`
 }
 
 // SchemaPatchConfig is the configuration for the schemapatch generator.

tools/codegen/pkg/schemacheck/generator.go

@@ -23,18 +23,37 @@ type Options struct {
 	// Disabled indicates whether the schemacheck generator is disabled or not.
 	// This defaults to false as the schemacheck generator is enabled by default.
 	Disabled bool
+
+	// EnabledComparators is a list of the comparators that should be enabled.
+	// If this is empty, the default comparators are enabled.
+	EnabledComparators []string
+
+	// DisabledComparators is a list of the comparators that should be disabled.
+	// If this is empty, no default comparators are disabled.
+	DisabledComparators []string
+
+	// ComparisonBase is the base branch/commit to compare against.
+	// This defaults to "master".
+	// This is not exposed via configuration as it must be set globally.
+	ComparisonBase string
 }
 
 // generator implements the generation.Generator interface.
 // It is designed to verify the CRD schema updates for a particular API group.
 type generator struct {
-	disabled bool
+	disabled            bool
+	enabledComparators  []string
+	disabledComparators []string
+	comparisonBase      string
 }
 
 // NewGenerator builds a new schemacheck generator.
 func NewGenerator(opts Options) generation.Generator {
 	return &generator{
-		disabled: opts.Disabled,
+		disabled:            opts.Disabled,
+		enabledComparators:  opts.EnabledComparators,
+		disabledComparators: opts.DisabledComparators,
+		comparisonBase:      opts.ComparisonBase,
 	}
 }
 
@@ -46,7 +65,10 @@ func (g *generator) ApplyConfig(config *generation.Config) generation.Generator
 	}
 
 	return NewGenerator(Options{
-		Disabled: config.SchemaCheck.Disabled,
+		Disabled:            config.SchemaCheck.Disabled,
+		EnabledComparators:  config.SchemaCheck.EnabledValidators,
+		DisabledComparators: config.SchemaCheck.DisabledValidators,
+		ComparisonBase:      g.comparisonBase,
 	})
 }
 
@@ -65,6 +87,13 @@ func (g *generator) GenGroup(groupCtx generation.APIGroupContext) error {
 	errs := []error{}
 
 	comparatorOptions := options.NewComparatorOptions()
+	comparatorOptions.EnabledComparators = g.enabledComparators
+	comparatorOptions.DisabledComparators = g.disabledComparators
+
+	if err := comparatorOptions.Validate(); err != nil {
+		return fmt.Errorf("could not validate comparator options: %w", err)
+	}
+
 	comparatorConfig, err := comparatorOptions.Complete()
 	if err != nil {
 		return fmt.Errorf("could not complete comparator options: %w", err)
@@ -87,7 +116,7 @@ func (g *generator) GenGroup(groupCtx generation.APIGroupContext) error {
 
 // genGroupVersion runs the schemacheck generator against a particular version of the API group.
 func (g *generator) genGroupVersion(group string, version generation.APIVersionContext, comparatorConfig *options.ComparatorConfig) error {
-	contexts, err := loadSchemaCheckGenerationContextsForVersion(version, "openshift/master")
+	contexts, err := loadSchemaCheckGenerationContextsForVersion(version, g.comparisonBase)
 	if err != nil {
 		return fmt.Errorf("could not load schema check generation contexts for group/version %s/%s: %w", group, version.Name, err)
 	}