validator

type BaseValidator ¶

type BaseValidator struct {
	*component.Base
	// contains filtered or unexported fields
}

BaseValidator owns request decoding and response publishing for a ValidationHandler. A panic produces a rejection so the scatter-gather coordinator can finish.

func NewBaseValidator(
	eventBus *busevents.EventBus,
	logger *slog.Logger,
	name string,
	handler ValidationHandler,
) *BaseValidator

func (v *BaseValidator) HandleEvent(event busevents.Event)

func (v *BaseValidator) HandlePanic(recovered any, event busevents.Event)

func (v *BaseValidator) HandleRequest(req *events.ConfigValidationRequest)

type BasicValidator ¶

type BasicValidator struct {
	*BaseValidator
}

BasicValidator validates basic structural configuration requirements.

This component subscribes to ConfigValidationRequest events and validates basic structural requirements such as: - Required fields are present - Field types and values are correct - Port numbers are in valid ranges - Non-empty slices where required

This validator uses the existing config.ValidateStructure() function and does NOT validate template syntax or JSONPath expressions (handled by specialized validators).

This component is part of the scatter-gather validation pattern and publishes ConfigValidationResponse events with validation results.

func NewBasicValidator(eventBus *busevents.EventBus, logger *slog.Logger) *BasicValidator

func (v *BasicValidator) Validate(_ context.Context, cfg *coreconfig.Config, version string) Verdict

type JSONPathValidator ¶

type JSONPathValidator struct {
	*BaseValidator
}

JSONPathValidator validates JSONPath expressions in configuration.

This component subscribes to ConfigValidationRequest events and validates all JSONPath expressions in the configuration using the k8s indexer package.

Validated fields: - WatchedResourcesIgnoreFields (all expressions) - WatchedResources[*].IndexBy (all expressions) - WatchedResources[*].FieldSelector (field.path=value format)

This component is part of the scatter-gather validation pattern and publishes ConfigValidationResponse events with validation results.

func NewJSONPathValidator(eventBus *busevents.EventBus, logger *slog.Logger) *JSONPathValidator

func (v *JSONPathValidator) Validate(_ context.Context, cfg *coreconfig.Config, version string) Verdict

type SchemaAcquisitionError ¶

type SchemaAcquisitionError struct {
	// Subject names what could not be validated without the schemas.
	Subject string
	Err     error
}

SchemaAcquisitionError reports that watched-resource schemas could not be acquired, so typed template access cannot be checked.

func (e *SchemaAcquisitionError) Error() string

func (e *SchemaAcquisitionError) Transient() bool

func (e *SchemaAcquisitionError) Unwrap() error

type SyncFailures ¶

type SyncFailures map[string][]string

SyncFailures contains the complete config-validator verdict by validator.

func ValidateConfigSync(
	ctx context.Context,
	cfg *coreconfig.Config,
	bootstrap TypeBootstrapper,
	runTimeout time.Duration,
	logger *slog.Logger,
) SyncFailures

func (f SyncFailures) Error() string

func (f SyncFailures) Flat() []string

type TemplateValidator ¶

type TemplateValidator struct {
	*BaseValidator
	// contains filtered or unexported fields
}

TemplateValidator validates template syntax in configuration.

This component subscribes to ConfigValidationRequest events and validates all templates together as a complete set. It uses helpers.ExtractTemplatesFromConfig to ensure validation matches production behavior exactly (DRY principle).

Templates are validated together, not in isolation, so snippets that reference each other via render, import, or inherit_context work correctly.

This component is part of the scatter-gather validation pattern and publishes ConfigValidationResponse events with validation results.

func NewTemplateValidator(eventBus *busevents.EventBus, logger *slog.Logger, bootstrap TypeBootstrapper) *TemplateValidator

func (v *TemplateValidator) Validate(ctx context.Context, cfg *coreconfig.Config, version string) Verdict

type TypeBootstrapper ¶

type TypeBootstrapper func(ctx context.Context, cfg *coreconfig.Config) (*typebootstrap.Result, error)

TypeBootstrapper runs the schema-acquisition pipeline for a candidate config and returns the resolved typed reflect.Types for each watched resource. Used by TemplateValidator so its engine compile sees the same typed globals the Stage-5 production engine will see — without this, a chart that uses typed Spec/Status access (e.g. `gw.Spec.Listeners`) would be false-positively rejected at Stage 1 against an envelope-only declaration set.

Production wiring binds this to controller.runTypeBootstrap with the iteration's K8s client captured in the closure; tests pass a stub that returns a Result built from in-memory schemas.

type ValidationHandler ¶

type ValidationHandler interface {
	Validate(ctx context.Context, cfg *coreconfig.Config, version string) Verdict
}

ValidationHandler validates a typed config without owning event responses.

type ValidationTestsValidator ¶

type ValidationTestsValidator struct {
	*BaseValidator
	// contains filtered or unexported fields
}

ValidationTestsValidator runs the config's embedded validationTests — the exact suite the `controller validate` CLI runs — as a scatter-gather validator. It guards live config changes: when a CRD update's tests fail the aggregation publishes ConfigInvalidEvent and the last-good config keeps serving.

The load path invokes the complete synchronous validator contract, which shares RunValidationTestsSync with this adapter.

It builds a throwaway engine from the candidate config (using the same live-schema TypeBootstrapper the TemplateValidator uses, so typed access in tests compiles identically to production) plus a temporary HAProxy validation tree for `haproxy_valid` assertions, runs the suite, and reports the outcome. This runs only on config load/change — never on the resource reconciliation hot path.

func NewValidationTestsValidator(eventBus *busevents.EventBus, logger *slog.Logger, bootstrap TypeBootstrapper) *ValidationTestsValidator

func (v *ValidationTestsValidator) Validate(ctx context.Context, cfg *coreconfig.Config, version string) Verdict

type Verdict ¶

type Verdict struct {
	Valid  bool
	Errors []string
	// Inconclusive marks Errors as reasons the handler could not judge the
	// config, not defects in it.
	Inconclusive bool
}

Verdict is a ValidationHandler's judgement of one config.