150 lines
4.0 KiB
Go
150 lines
4.0 KiB
Go
package pipeline
|
|
|
|
import (
|
|
"fmt"
|
|
"sort"
|
|
"strings"
|
|
|
|
"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
|
|
)
|
|
|
|
type ValidatorConstructor func() (contracts.Validator, error)
|
|
|
|
type ValidatorSpec struct {
|
|
Key string `json:"key"`
|
|
ExecutionClass contracts.ExecutionClass `json:"execution_class"`
|
|
}
|
|
|
|
type ValidatorRegistry struct {
|
|
constructors map[string]ValidatorConstructor
|
|
specs map[string]ValidatorSpec
|
|
}
|
|
|
|
func NewValidatorRegistry() *ValidatorRegistry {
|
|
return &ValidatorRegistry{
|
|
constructors: make(map[string]ValidatorConstructor),
|
|
specs: make(map[string]ValidatorSpec),
|
|
}
|
|
}
|
|
|
|
func (r *ValidatorRegistry) Register(key string, constructor ValidatorConstructor) error {
|
|
return r.RegisterWithSpec(ValidatorSpec{Key: key, ExecutionClass: contracts.ExecutionClassDeterministic}, constructor)
|
|
}
|
|
|
|
func (r *ValidatorRegistry) RegisterWithSpec(spec ValidatorSpec, constructor ValidatorConstructor) error {
|
|
if r == nil {
|
|
return fmt.Errorf("validator registry must not be nil")
|
|
}
|
|
|
|
normalizedSpec, err := normalizeValidatorSpec(spec)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if constructor == nil {
|
|
return fmt.Errorf("validator constructor for %q must not be nil", normalizedSpec.Key)
|
|
}
|
|
if _, ok := r.constructors[normalizedSpec.Key]; ok {
|
|
return fmt.Errorf("validator %q is already registered", normalizedSpec.Key)
|
|
}
|
|
|
|
if r.constructors == nil {
|
|
r.constructors = make(map[string]ValidatorConstructor)
|
|
}
|
|
if r.specs == nil {
|
|
r.specs = make(map[string]ValidatorSpec)
|
|
}
|
|
r.constructors[normalizedSpec.Key] = constructor
|
|
r.specs[normalizedSpec.Key] = normalizedSpec
|
|
return nil
|
|
}
|
|
|
|
func (r *ValidatorRegistry) Build(key string) (contracts.Validator, error) {
|
|
if r == nil {
|
|
return nil, fmt.Errorf("validator registry must not be nil")
|
|
}
|
|
|
|
normalizedKey := strings.TrimSpace(key)
|
|
if normalizedKey == "" {
|
|
return nil, fmt.Errorf("validator key must not be empty")
|
|
}
|
|
|
|
constructor, ok := r.constructors[normalizedKey]
|
|
if !ok {
|
|
return nil, fmt.Errorf("validator %q is not registered", normalizedKey)
|
|
}
|
|
|
|
validator, err := constructor()
|
|
if err != nil {
|
|
return nil, fmt.Errorf("build validator %q: %w", normalizedKey, err)
|
|
}
|
|
if validator == nil {
|
|
return nil, fmt.Errorf("validator %q constructor returned nil", normalizedKey)
|
|
}
|
|
if validator.Name() != normalizedKey {
|
|
return nil, fmt.Errorf("validator %q returned name %q", normalizedKey, validator.Name())
|
|
}
|
|
spec, ok := r.specs[normalizedKey]
|
|
if !ok {
|
|
return nil, fmt.Errorf("validator %q spec is not registered", normalizedKey)
|
|
}
|
|
if validator.ExecutionClass() != spec.ExecutionClass {
|
|
return nil, fmt.Errorf("validator %q returned execution class %q, want %q", normalizedKey, validator.ExecutionClass(), spec.ExecutionClass)
|
|
}
|
|
|
|
return validator, nil
|
|
}
|
|
|
|
func (r *ValidatorRegistry) Spec(key string) (ValidatorSpec, bool) {
|
|
if r == nil {
|
|
return ValidatorSpec{}, false
|
|
}
|
|
|
|
spec, ok := r.specs[strings.TrimSpace(key)]
|
|
if !ok {
|
|
return ValidatorSpec{}, false
|
|
}
|
|
return spec, true
|
|
}
|
|
|
|
func (r *ValidatorRegistry) RegisteredSpecs() []ValidatorSpec {
|
|
if r == nil || len(r.specs) == 0 {
|
|
return nil
|
|
}
|
|
|
|
keys := make([]string, 0, len(r.specs))
|
|
for key := range r.specs {
|
|
keys = append(keys, key)
|
|
}
|
|
sort.Strings(keys)
|
|
|
|
specs := make([]ValidatorSpec, 0, len(keys))
|
|
for _, key := range keys {
|
|
specs = append(specs, r.specs[key])
|
|
}
|
|
return specs
|
|
}
|
|
|
|
func (r *ValidatorRegistry) RegisteredKeys() []string {
|
|
if r == nil {
|
|
return nil
|
|
}
|
|
|
|
return sortedRegistryKeys(r.constructors)
|
|
}
|
|
|
|
func normalizeValidatorSpec(spec ValidatorSpec) (ValidatorSpec, error) {
|
|
normalized := ValidatorSpec{
|
|
Key: strings.TrimSpace(spec.Key),
|
|
ExecutionClass: spec.ExecutionClass,
|
|
}
|
|
if normalized.Key == "" {
|
|
return ValidatorSpec{}, fmt.Errorf("validator key must not be empty")
|
|
}
|
|
switch normalized.ExecutionClass {
|
|
case contracts.ExecutionClassDeterministic, contracts.ExecutionClassLLMBacked:
|
|
default:
|
|
return ValidatorSpec{}, fmt.Errorf("validator %q execution class %q is not supported", normalized.Key, normalized.ExecutionClass)
|
|
}
|
|
return normalized, nil
|
|
}
|