pluggablevalidator

type Client struct {
	// Name is the operator-facing validator name from
	// spec.validators[i].name. Surfaced in synthetic protocol-level
	// diagnostics so users can identify which validator failed.
	Name string

	// SocketPath is the absolute filesystem path to the validator's
	// unix domain socket.
	SocketPath string

	// Timeout is the per-call deadline for one request-response
	// cycle (acquire + write + read). Zero falls back to
	// DefaultTimeout.
	Timeout time.Duration

	// MaxConnections caps the pool size. Zero falls back to
	// DefaultMaxConnections; values < 1 are clamped up to 1.
	MaxConnections int
	// contains filtered or unexported fields
}

type Diagnostic struct {
	Path    string `json:"path"`
	Line    uint32 `json:"line"`
	Column  uint32 `json:"column"`
	Message string `json:"message"`
}

type File struct {
	Path    string `json:"path"`
	Content string `json:"content"`
	// Kind tells the validator whether to validate this file or merely make
	// it available to whatever validates the others. Empty means
	// FileKindConfig and is omitted from the wire, so a request carrying no
	// data files is byte-identical to one from before this field existed.
	Kind FileKind `json:"kind,omitempty"`
}

type FileKind string

type Manager struct {
	// contains filtered or unexported fields
}

type ManagerConfig struct {
	// Name is the operator-facing validator identifier.
	Name string
	// SocketPath is the absolute filesystem path to the validator's
	// unix domain socket.
	SocketPath string
	// Files is the list of glob patterns matched against rendered
	// file paths to decide which files to send to this validator.
	// Patterns follow Go's `path/filepath.Match` rules.
	Files []string
	// DataFiles is the list of glob patterns for files this validator needs
	// in order to check the ones it validates, but must not validate on
	// their own — a WAF ruleset a hub config `Include`s. Every matching
	// file is attached to every request sent to this validator, marked
	// FileKindData.
	//
	// A file matching both lists is data: it is the reference target, and
	// parsing it as a config would produce a spurious error rather than a
	// finding about the config that references it.
	DataFiles []string
	// Timeout is the per-call deadline for one (file, validator)
	// request-response cycle. Zero falls back to DefaultTimeout.
	Timeout time.Duration
	// MaxConnections caps the controller-side pool to this
	// validator's socket. Zero falls back to DefaultMaxConnections.
	MaxConnections int
}

type ManagerOption func(*Manager)

type Request struct {
	ProtocolVersion int    `json:"protocol_version"`
	Files           []File `json:"files"`
	// StagedRoot is the directory the data files' paths are relative to, as
	// the process that will load them sees it at runtime.
	//
	// A validated config references its files by their runtime path
	// (`/etc/haproxy/general/crs-*.conf`) while the request carries them under
	// the controller's own identifiers (`general/crs-….conf`). The validator
	// cannot bridge the two on its own, and inferring the link by matching a
	// path suffix would resolve a mistyped directory just as readily as the
	// right one — so it is stated rather than guessed.
	//
	// Omitted when empty, so a request without data files is byte-identical to
	// one from before this field existed.
	StagedRoot string `json:"staged_root,omitempty"`
}

type Response struct {
	ProtocolVersion int          `json:"protocol_version"`
	Result          Result       `json:"result"`
	Warnings        []Diagnostic `json:"warnings"`
	Errors          []Diagnostic `json:"errors"`
	// contains filtered or unexported fields
}

type Result string

type Severity string

type ValidationOutcome struct {
	Warnings []Diagnostic
	Errors   []Diagnostic
	Err      error
}