Files
archie/internal/infrastructure/configuration/validate.go
T

369 lines
15 KiB
Go

package configuration
import (
"fmt"
"net/url"
"path/filepath"
"slices"
"strings"
"github.com/samcharles93/archie-core/internal/config"
)
// Recognised enum values, named so validation and its error message cannot
// disagree about what is allowed.
const (
forgeTypeGitHub = "github"
forgeTypeGitea = "gitea"
forgeTypeNone = "none"
forgeTypeOff = "off"
forgeTypeDisabled = "disabled"
dispatchTriggerAssignee = "assignee"
dispatchTriggerLabel = "label"
dispatchTriggerEither = "either"
// memoryEngineBuiltin is the only domain/memory engine implemented so
// far (internal/infrastructure/memory.BuiltinEngine). Extend
// memoryEngines, not this list of one, as further engines land.
memoryEngineBuiltin = "builtin"
)
var (
forgeTypes = []string{forgeTypeGitHub, forgeTypeGitea, forgeTypeNone, forgeTypeOff, forgeTypeDisabled}
dispatchTriggers = []string{dispatchTriggerAssignee, dispatchTriggerLabel, dispatchTriggerEither}
natsModes = []string{config.NATSModeEmbedded, config.NATSModeExternal}
forgeIntakes = []string{config.ForgeIntakePoll, config.ForgeIntakeWebhook, config.ForgeIntakeBoth}
memoryEngines = []string{memoryEngineBuiltin}
)
// Validate runs the same checks Loader applies before accepting a config,
// against a config.Config value already built in memory -- e.g. by archied
// setup, before it has written anything to disk.
//
// Like validate, it does not apply defaults. Several checks (dispatch.trigger,
// forge.type) only pass once a default has been filled
// in, and defaulting is currently unexported ((*Loader).applyDefaults). A
// cfg built by hand, with those fields left zero-valued, will fail
// validation that a config loaded through [Loader.File] would pass. Callers
// that build a config directly (rather than decoding one through a Loader)
// must fill in the same defaults themselves, or -- the safer option, since
// it can't drift from what the real load path does -- render the config to
// TOML and load it back through a Loader instead of calling Validate on the
// in-memory value directly.
func Validate(cfg *config.Config) error {
return validate(cfg)
}
// validate reports the first problem that would stop the daemon running.
// It does not modify cfg -- run applyDefaults first.
func validate(cfg *config.Config) error {
if err := validateDispatch(cfg); err != nil {
return err
}
if err := validateForgeIntake(cfg); err != nil {
return err
}
if err := validateProviders(cfg.Providers); err != nil {
return err
}
if len(cfg.Identities) > 0 {
if err := validateIdentities(cfg.Identities); err != nil {
return err
}
} else if err := validateSingleIdentity(cfg); err != nil {
return err
}
if err := validatePollInterval(cfg); err != nil {
return err
}
if err := validateNATS(cfg); err != nil {
return err
}
if err := validateContainers(cfg); err != nil {
return err
}
if err := validateMemory(cfg); err != nil {
return err
}
if err := validateImage(cfg); err != nil {
return err
}
return validateCapture(cfg)
}
// validateImage rejects an enabled hosted provider with no class or no
// resolvable credential, and a Default naming a provider that is not both
// present and enabled -- either would let /image silently fall back to
// "always ask" (harmless) or fail at call time with a confusing error
// (not harmless). An absent [image] section is valid and registers no
// provider, matching the epic's non-goal that a paid provider must never
// activate by omission.
func validateImage(cfg *config.Config) error {
for name, p := range cfg.Image.Hosted {
if !p.Enabled {
continue
}
if p.Class == "" {
return fmt.Errorf("%w: image.hosted.%s.class is required when enabled", ErrInvalidInput, name)
}
if p.APIKeyEnv == "" && p.APIKey == (config.SecretRef{}) {
return fmt.Errorf("%w: image.hosted.%s requires api_key_env or api_key when enabled", ErrInvalidInput, name)
}
}
for name, p := range cfg.Image.Local {
if p.Enabled && p.Backend == "" {
return fmt.Errorf("%w: image.local.%s.backend is required when enabled", ErrInvalidInput, name)
}
}
if cfg.Image.Default != "" {
hosted, hostedOK := cfg.Image.Hosted[cfg.Image.Default]
local, localOK := cfg.Image.Local[cfg.Image.Default]
switch {
case hostedOK && hosted.Enabled, localOK && local.Enabled:
// found and enabled
default:
return fmt.Errorf("%w: image.default %q must name an enabled provider under image.hosted or image.local", ErrInvalidInput, cfg.Image.Default)
}
}
return nil
}
// validateMemory rejects an engine name outside memoryEngines. Empty is
// valid input to Validate (applyDefaults resolves it to memoryEngineBuiltin
// before this runs on the real load path); it is not "unknown" so it does
// not error here.
func validateMemory(cfg *config.Config) error {
if cfg.Memory.Engine != "" && !oneOf(cfg.Memory.Engine, memoryEngines) {
return fmt.Errorf("%w: memory.engine %q (want %s)", ErrInvalidInput, cfg.Memory.Engine, list(memoryEngines))
}
// memory.provider is the legacy external-MemoryProvider identifier for
// internal/memory.Manager.RegisterExternal. No external provider is
// implemented anywhere in the repo to construct and register (only the
// builtin file-backed one exists), so setupMemory has never called
// RegisterExternal and setting this field has always silently done
// nothing -- an operator who sets it reasonably believes they
// configured something. Reject it loudly instead of accepting a value
// with no effect; drop this once a real external provider (or the new
// domain/memory engine family's Honcho proof,
// archie-core-1786637492031) makes the field meaningful again.
if cfg.Memory.Provider != "" {
return fmt.Errorf("%w: memory.provider %q is set, but no external memory provider is implemented -- remove it (memory.engine selects the new engine family instead)", ErrInvalidInput, cfg.Memory.Provider)
}
return nil
}
// validateCapture rejects negative capture settings. applyDefaults fills
// every zero value with a positive default, so this only fires on an
// explicit negative value -- which would make time.Duration/AddDate math
// and the token-bucket rate limiter behave nonsensically (e.g. a negative
// retention window would prune every row on every insert, including the one
// just written).
func validateCapture(cfg *config.Config) error {
if cfg.Capture.Retention < 0 {
return fmt.Errorf("%w: capture.retention must not be negative", ErrInvalidInput)
}
if cfg.Capture.MaxEvents < 0 {
return fmt.Errorf("%w: capture.max_events must not be negative", ErrInvalidInput)
}
if cfg.Capture.MaxBodyBytes < 0 {
return fmt.Errorf("%w: capture.max_body_bytes must not be negative", ErrInvalidInput)
}
if cfg.Capture.RatePerSecond < 0 {
return fmt.Errorf("%w: capture.rate_per_second must not be negative", ErrInvalidInput)
}
if cfg.Capture.RateBurst < 0 {
return fmt.Errorf("%w: capture.rate_burst must not be negative", ErrInvalidInput)
}
return nil
}
// validatePollInterval rejects a non-positive poll interval.
// applyDefaults fills PollInterval == 0 with the default, so this only
// fires on an explicit negative value -- which would panic
// time.NewTicker/Reset in the daemon's poll loops, at boot and (worse)
// on a SIGHUP reload mid-run, when the edit that broke it is no longer
// fresh in the operator's mind.
func validatePollInterval(cfg *config.Config) error {
if cfg.PollInterval <= 0 {
return fmt.Errorf("%w: poll_interval must be positive", ErrInvalidInput)
}
return nil
}
// validateDispatch rejects a "label" or "either" trigger left with no label
// to match. GitHub's issues-list API treats an empty label filter as no
// filter at all and returns every open issue in the repo -- a live incident
// (GH#445) queued 124 unrelated issues in one poll cycle this way, after
// [dispatch.labels] (a different field, mapping task states to their own
// labels) was configured while the actual trigger-match label was left
// blank.
func validateDispatch(cfg *config.Config) error {
if !oneOf(cfg.Dispatch.Trigger, dispatchTriggers) {
return fmt.Errorf("%w: dispatch.trigger %q (want %s)", ErrInvalidInput, cfg.Dispatch.Trigger, list(dispatchTriggers))
}
if (cfg.Dispatch.Trigger == dispatchTriggerLabel || cfg.Dispatch.Trigger == dispatchTriggerEither) && cfg.Label == "" {
return fmt.Errorf("%w: label is required when dispatch.trigger is %q (an empty label matches every open issue)", ErrInvalidInput, cfg.Dispatch.Trigger)
}
return nil
}
// validateForgeIntake checks the forge intake mode and that webhook intake has
// the secret and listen address it needs. An unset intake resolves to "poll"
// without mutating cfg, so Validate (which does not apply defaults) accepts a
// hand-built config the same way Loader.File accepts its on-disk form.
func validateForgeIntake(cfg *config.Config) error {
intake := cfg.Forge.Intake
if intake == "" {
intake = config.ForgeIntakePoll
}
if !oneOf(intake, forgeIntakes) {
return fmt.Errorf("%w: forge.intake %q (want %s)", ErrInvalidInput, cfg.Forge.Intake, list(forgeIntakes))
}
if intake == config.ForgeIntakeWebhook || intake == config.ForgeIntakeBoth {
if cfg.Forge.WebhookSecret == (config.SecretRef{}) {
return fmt.Errorf("%w: forge.webhook_secret is required when forge.intake is %q", ErrInvalidInput, intake)
}
if cfg.Forge.WebhookAddr == "" {
return fmt.Errorf("%w: forge.webhook_addr is required when forge.intake is %q", ErrInvalidInput, intake)
}
}
return nil
}
// validateProviders rejects base URLs carrying credentials or query state.
// A provider URL is used to build API requests, so userinfo or a stray query
// string would be silently attached to every call.
func validateProviders(providers map[string]config.Provider) error {
for name, provider := range providers {
if provider.BaseURL == "" {
continue
}
u, err := url.Parse(provider.BaseURL)
if err != nil {
return fmt.Errorf("%w: providers.%s.base_url: %w", ErrInvalidInput, name, err)
}
if u.User != nil || u.RawQuery != "" || u.Fragment != "" {
return fmt.Errorf("%w: providers.%s.base_url must not contain userinfo, query parameters, or a fragment", ErrInvalidInput, name)
}
}
return nil
}
func validateIdentities(identities []config.IdentityConfig) error {
for i, id := range identities {
if id.Name == "" {
return fmt.Errorf("%w: identities[%d].name is required", ErrInvalidInput, i)
}
if id.BotUser == "" {
return fmt.Errorf("%w: identities[%d].bot_user is required", ErrInvalidInput, i)
}
if len(id.Repos) == 0 {
return fmt.Errorf("%w: identities[%d] has no [[identities.repos]] entries -- at least one is required", ErrInvalidInput, i)
}
if !oneOf(id.Forge.Type, forgeTypes) {
return fmt.Errorf("%w: identities[%d].forge.type %q (want %s)", ErrInvalidInput, i, id.Forge.Type, list(forgeTypes))
}
if !ForgeDisabled(id.Forge.Type) && id.Forge.Token == (config.SecretRef{}) {
return fmt.Errorf("%w: identities[%d].forge.token is required (each identity needs its own secret reference; unlike the top-level [forge], there is no default)", ErrInvalidInput, i)
}
if err := validateRepos(id.Repos); err != nil {
return fmt.Errorf("identities[%d]: %w", i, err)
}
}
return nil
}
// ForgeDisabled reports whether a forge type explicitly opts out of forge
// integration. It is the single definition shared by config validation and
// cmd/archied's resolveForge: adding or removing an alias here applies to
// both paths together. It is not consulted by forge.New, which has its own
// construction-time dispatch for disabled types (and the empty string);
// that dispatch is a different concern from this validation predicate.
func ForgeDisabled(t string) bool {
return t == forgeTypeNone || t == forgeTypeOff || t == forgeTypeDisabled
}
func validateSingleIdentity(cfg *config.Config) error {
if cfg.BotUser == "" {
return fmt.Errorf("%w: bot_user is required (or define [[identities]])", ErrInvalidInput)
}
if !oneOf(cfg.Forge.Type, forgeTypes) {
return fmt.Errorf("%w: forge.type %q (want %s)", ErrInvalidInput, cfg.Forge.Type, list(forgeTypes))
}
return validateRepos(cfg.Repos)
}
func validateRepos(repos []config.Repo) error {
for i, r := range repos {
if r.Owner == "" || r.Name == "" {
return fmt.Errorf("%w: repos[%d] needs owner and name", ErrInvalidInput, i)
}
if glob := r.ResolvedTestGlob(); glob != "" {
if _, err := filepath.Match(glob, ""); err != nil {
return fmt.Errorf("%w: repos[%d] test_glob %q: %w", ErrInvalidInput, i, glob, err)
}
}
}
return nil
}
// effectiveNATSMode resolves an unset nats.mode from url without mutating cfg,
// so validation that reads the mode never has to know whether the operator
// spelled it or left it to default. validateNATS and validateContainers both
// consult it, so they cannot disagree about which mode a config is in.
func effectiveNATSMode(cfg *config.Config) string {
if cfg.NATS.Mode != "" {
return cfg.NATS.Mode
}
if cfg.NATS.URL != "" {
return config.NATSModeExternal
}
return config.NATSModeEmbedded
}
// validateNATS checks the nats mode and its consistency with url. It resolves
// an unset mode from url without mutating cfg, so Validate (which documents it
// does not apply defaults) accepts a hand-built config the same way Loader.File
// accepts its on-disk form.
func validateNATS(cfg *config.Config) error {
mode := effectiveNATSMode(cfg)
if !oneOf(mode, natsModes) {
return fmt.Errorf("%w: nats.mode %q (want %s)", ErrInvalidInput, cfg.NATS.Mode, list(natsModes))
}
switch mode {
case config.NATSModeExternal:
if cfg.NATS.URL == "" {
return fmt.Errorf("%w: nats.url is required when nats.mode is %q", ErrInvalidInput, config.NATSModeExternal)
}
case config.NATSModeEmbedded:
if cfg.NATS.URL != "" {
return fmt.Errorf("%w: nats.url must be empty when nats.mode is %q", ErrInvalidInput, mode)
}
}
return nil
}
// validateContainers checks the mandatory managed-worker configuration.
// Embedded and external NATS are both worker-reachable deployment shapes.
func validateContainers(cfg *config.Config) error {
if cfg.Containers.Image == "" {
return fmt.Errorf("%w: containers.image is required for autonomous workflow workers", ErrInvalidInput)
}
if cfg.Containers.VolumeTTL < 0 {
return fmt.Errorf("%w: containers.volume_ttl must not be negative", ErrInvalidInput)
}
return nil
}
// oneOf reports whether value is in allowed.
func oneOf(value string, allowed []string) bool {
return slices.Contains(allowed, value)
}
// list renders allowed values for an error message.
func list(values []string) string { return strings.Join(values, ", ") }
// isOff reports the documented "disable this" spelling.
func isOff(value string) bool { return strings.EqualFold(value, "off") }