138 lines
3.9 KiB
Go
138 lines
3.9 KiB
Go
package pipeline
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
|
|
"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
|
|
)
|
|
|
|
type ChunkerConstructor func() (contracts.Chunker, error)
|
|
type ChunkerBuilder func(BuildRequest) (contracts.Chunker, error)
|
|
|
|
type ChunkerRegistry struct {
|
|
builders map[string]ChunkerBuilder
|
|
optionValidators map[string]OptionValidator
|
|
specs map[string]ModuleSpec
|
|
}
|
|
|
|
func NewChunkerRegistry() *ChunkerRegistry {
|
|
return &ChunkerRegistry{
|
|
builders: make(map[string]ChunkerBuilder),
|
|
optionValidators: make(map[string]OptionValidator),
|
|
specs: make(map[string]ModuleSpec),
|
|
}
|
|
}
|
|
|
|
func (r *ChunkerRegistry) Register(key string, constructor ChunkerConstructor) error {
|
|
return r.RegisterWithSpec(defaultModuleSpec(key, StageChunk), constructor)
|
|
}
|
|
|
|
func (r *ChunkerRegistry) RegisterWithSpec(spec ModuleSpec, constructor ChunkerConstructor) error {
|
|
if constructor == nil {
|
|
return fmt.Errorf("chunker constructor for %q must not be nil", strings.TrimSpace(spec.Key))
|
|
}
|
|
return r.RegisterBuilderWithSpec(spec, rejectUnconfiguredOptions, func(BuildRequest) (contracts.Chunker, error) {
|
|
return constructor()
|
|
})
|
|
}
|
|
|
|
func (r *ChunkerRegistry) RegisterBuilderWithSpec(spec ModuleSpec, validateOptions OptionValidator, builder ChunkerBuilder) error {
|
|
if r == nil {
|
|
return fmt.Errorf("chunker registry must not be nil")
|
|
}
|
|
|
|
normalizedSpec := normalizeModuleSpec(spec)
|
|
if err := validateModuleSpec("chunker", StageChunk, normalizedSpec); err != nil {
|
|
return err
|
|
}
|
|
if validateOptions == nil {
|
|
return fmt.Errorf("chunker option validator for %q must not be nil", normalizedSpec.Key)
|
|
}
|
|
if builder == nil {
|
|
return fmt.Errorf("chunker builder for %q must not be nil", normalizedSpec.Key)
|
|
}
|
|
if _, ok := r.builders[normalizedSpec.Key]; ok {
|
|
return fmt.Errorf("chunker %q is already registered", normalizedSpec.Key)
|
|
}
|
|
|
|
if r.builders == nil {
|
|
r.builders = make(map[string]ChunkerBuilder)
|
|
}
|
|
if r.optionValidators == nil {
|
|
r.optionValidators = make(map[string]OptionValidator)
|
|
}
|
|
if r.specs == nil {
|
|
r.specs = make(map[string]ModuleSpec)
|
|
}
|
|
r.builders[normalizedSpec.Key] = builder
|
|
r.optionValidators[normalizedSpec.Key] = validateOptions
|
|
r.specs[normalizedSpec.Key] = cloneModuleSpec(normalizedSpec)
|
|
return nil
|
|
}
|
|
|
|
func (r *ChunkerRegistry) Build(key string) (contracts.Chunker, error) {
|
|
return r.BuildWithRequest(key, BuildRequest{})
|
|
}
|
|
|
|
func (r *ChunkerRegistry) BuildWithRequest(key string, request BuildRequest) (contracts.Chunker, error) {
|
|
if r == nil {
|
|
return nil, fmt.Errorf("chunker registry must not be nil")
|
|
}
|
|
|
|
normalizedKey := strings.TrimSpace(key)
|
|
if normalizedKey == "" {
|
|
return nil, fmt.Errorf("chunker key must not be empty")
|
|
}
|
|
|
|
builder, ok := r.builders[normalizedKey]
|
|
if !ok {
|
|
return nil, fmt.Errorf("chunker %q is not registered", normalizedKey)
|
|
}
|
|
|
|
chunker, err := builder(cloneBuildRequest(request))
|
|
if err != nil {
|
|
return nil, fmt.Errorf("build chunker %q: %w", normalizedKey, err)
|
|
}
|
|
if chunker == nil {
|
|
return nil, fmt.Errorf("chunker %q constructor returned nil", normalizedKey)
|
|
}
|
|
if chunker.Key() != normalizedKey {
|
|
return nil, fmt.Errorf("chunker %q returned key %q", normalizedKey, chunker.Key())
|
|
}
|
|
|
|
return chunker, nil
|
|
}
|
|
|
|
func (r *ChunkerRegistry) ValidateOptions(key string, options map[string]any) error {
|
|
if r == nil {
|
|
return fmt.Errorf("chunker registry must not be nil")
|
|
}
|
|
normalizedKey := strings.TrimSpace(key)
|
|
validator, ok := r.optionValidators[normalizedKey]
|
|
if !ok {
|
|
return fmt.Errorf("chunker %q is not registered", normalizedKey)
|
|
}
|
|
return validateRegisteredOptions(validator, options)
|
|
}
|
|
|
|
func (r *ChunkerRegistry) Spec(key string) (ModuleSpec, bool) {
|
|
if r == nil {
|
|
return ModuleSpec{}, false
|
|
}
|
|
|
|
spec, ok := r.specs[strings.TrimSpace(key)]
|
|
if !ok {
|
|
return ModuleSpec{}, false
|
|
}
|
|
return cloneModuleSpec(spec), true
|
|
}
|
|
|
|
func (r *ChunkerRegistry) RegisteredKeys() []string {
|
|
if r == nil {
|
|
return nil
|
|
}
|
|
|
|
return sortedRegistryKeys(r.builders)
|
|
}
|