385 lines
14 KiB
Go
385 lines
14 KiB
Go
package configuration
|
|
|
|
import (
|
|
"fmt"
|
|
"net/url"
|
|
"path/filepath"
|
|
"regexp"
|
|
"slices"
|
|
"strings"
|
|
|
|
"github.com/samcharles93/archie-core/internal/config"
|
|
"github.com/samcharles93/archie-core/internal/domain/identity"
|
|
)
|
|
|
|
// 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"
|
|
)
|
|
|
|
// forgeTypePattern is a package name: forge.type names the installed forge
|
|
// package that serves the instance, or disables the forge.
|
|
var forgeTypePattern = regexp.MustCompile(`^[a-z0-9][a-z0-9-]*$`)
|
|
|
|
var (
|
|
dispatchTriggers = []string{dispatchTriggerAssignee, dispatchTriggerLabel, dispatchTriggerEither}
|
|
natsModes = []string{config.NATSModeEmbedded, config.NATSModeExternal}
|
|
forgeIntakes = []string{config.ForgeIntakePoll, config.ForgeIntakeWebhook, config.ForgeIntakeBoth}
|
|
memoryEngines = []string{memoryEngineBuiltin}
|
|
)
|
|
|
|
// Validate checks an effective configuration, including settings the control
|
|
// plane owns. It does not apply defaults.
|
|
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 := validateBootstrap(cfg); err != nil {
|
|
return err
|
|
}
|
|
return validateDatabaseOwned(cfg)
|
|
}
|
|
|
|
// validateBootstrap checks the settings a file configuration still owns,
|
|
// skipping those the control plane stores.
|
|
func validateBootstrap(cfg *config.Config) error {
|
|
if err := validateForgeIntake(cfg); err != nil {
|
|
return err
|
|
}
|
|
if err := validateIdentityStructure(cfg); err != nil {
|
|
return err
|
|
}
|
|
if err := validateNATS(cfg); err != nil {
|
|
return err
|
|
}
|
|
if err := validateMemory(cfg); err != nil {
|
|
return err
|
|
}
|
|
if err := validateCurators(cfg); err != nil {
|
|
return err
|
|
}
|
|
return validateCapture(cfg)
|
|
}
|
|
|
|
// validateDatabaseOwned checks the settings the control plane owns:
|
|
// providers, scheduling, containers and repositories.
|
|
func validateDatabaseOwned(cfg *config.Config) error {
|
|
if err := validateDispatch(cfg); err != nil {
|
|
return err
|
|
}
|
|
if err := validateProviders(cfg.Providers); err != nil {
|
|
return err
|
|
}
|
|
if err := validatePollInterval(cfg); err != nil {
|
|
return err
|
|
}
|
|
if err := validateContainers(cfg); err != nil {
|
|
return err
|
|
}
|
|
return validateRepositoryContents(cfg)
|
|
}
|
|
|
|
// validateCurators rejects a curator definition with no interval. The
|
|
// interval is a live-path value: a definition missing it is refused with a
|
|
// clear error rather than defaulted at registration or pass time, so a
|
|
// config-defined curator can never silently inherit a code constant.
|
|
func validateCurators(cfg *config.Config) error {
|
|
for i, def := range cfg.Curators {
|
|
if def.Interval <= 0 {
|
|
return fmt.Errorf("%w: curators[%d].interval must be positive", ErrInvalidInput, i)
|
|
}
|
|
}
|
|
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))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// validateCapture rejects negative capture settings.
|
|
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 negative poll interval.
|
|
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 with no label: an
|
|
// empty label filter matches every open issue.
|
|
func validateDispatch(cfg *config.Config) error {
|
|
if !DispatchTriggerValid(cfg.Dispatch.Trigger) {
|
|
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
|
|
}
|
|
|
|
// DispatchTriggerValid reports whether trigger is a known discovery rule.
|
|
func DispatchTriggerValid(trigger string) bool {
|
|
return oneOf(trigger, dispatchTriggers)
|
|
}
|
|
|
|
// validateForgeIntake checks the intake mode and webhook settings, and
|
|
// rejects webhook intake with [[identities]] or on an identity.
|
|
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 len(cfg.Identities) > 0 {
|
|
return fmt.Errorf("%w: forge.intake %q is not supported alongside [[identities]]: webhook intake is single-identity only, so every identity would silently keep polling (drop the [[identities]] blocks, or set forge.intake = %q and let each identity poll)",
|
|
ErrInvalidInput, intake, config.ForgeIntakePoll)
|
|
}
|
|
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
|
|
}
|
|
|
|
// validateIdentityStructure checks identity definitions, excluding their
|
|
// repository lists.
|
|
func validateIdentityStructure(cfg *config.Config) error {
|
|
if len(cfg.Identities) == 0 {
|
|
return validateSingleIdentity(cfg)
|
|
}
|
|
return validateIdentities(cfg.Identities)
|
|
}
|
|
|
|
func validateIdentities(identities []config.IdentityConfig) error {
|
|
for i, id := range identities {
|
|
// The name rule belongs to the identity feature, which the store path
|
|
// also applies (identity.New). Calling it here keeps a name the file
|
|
// accepts from being a name the store refuses.
|
|
if !identity.ValidDisplayName(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)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// ForgeDisabled reports whether a forge type disables forge integration.
|
|
func ForgeDisabled(t string) bool {
|
|
return t == forgeTypeNone || t == forgeTypeOff || t == forgeTypeDisabled
|
|
}
|
|
|
|
func validateSingleIdentity(cfg *config.Config) error {
|
|
// bot_user becomes the seeded identity's display name
|
|
// (configuredIdentityNames -> identity.New), so it is judged by the same
|
|
// rule rather than a second empty-string test.
|
|
if !identity.ValidDisplayName(cfg.BotUser) {
|
|
return fmt.Errorf("%w: bot_user is required (or define [[identities]])", ErrInvalidInput)
|
|
}
|
|
if !forgeTypePattern.MatchString(cfg.Forge.Type) {
|
|
return fmt.Errorf("%w: forge.type %q (want none or the name of an installed forge package)", ErrInvalidInput, cfg.Forge.Type)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// validateRepositoryContents checks the shared and per-identity repository
|
|
// lists.
|
|
func validateRepositoryContents(cfg *config.Config) error {
|
|
if len(cfg.Identities) == 0 {
|
|
return ValidateRepositories(cfg.Repos)
|
|
}
|
|
for i, id := range cfg.Identities {
|
|
if err := ValidateRepositories(id.Repos); err != nil {
|
|
return fmt.Errorf("identities[%d]: %w", i, err)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// ValidateRepositories checks a repository list: owner and name set, no
|
|
// duplicates, and a valid test glob.
|
|
func ValidateRepositories(repos []config.Repo) error {
|
|
seen := make(map[string]struct{}, len(repos))
|
|
for i, r := range repos {
|
|
if r.Owner == "" || r.Name == "" {
|
|
return fmt.Errorf("%w: repos[%d] needs owner and name", ErrInvalidInput, i)
|
|
}
|
|
if _, exists := seen[r.FullName()]; exists {
|
|
return fmt.Errorf("%w: repos[%d] duplicates %q", ErrInvalidInput, i, r.FullName())
|
|
}
|
|
seen[r.FullName()] = struct{}{}
|
|
if err := validateTestGlob(r.ResolvedTestGlob()); err != nil {
|
|
return fmt.Errorf("%w: repos[%d] %w", ErrInvalidInput, i, err)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// validateTestGlob reports whether glob is a pattern the test-protection gate can
|
|
// compile. It has one caller on each side through ValidateRepositories, so the
|
|
// rule has one definition rather than a copy per layer.
|
|
func validateTestGlob(glob string) error {
|
|
if glob == "" {
|
|
return nil
|
|
}
|
|
if _, err := filepath.Match(glob, ""); err != nil {
|
|
return fmt.Errorf("test_glob %q: %w", 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)
|
|
}
|
|
if err := cfg.Containers.ValidateProfiles(); err != nil {
|
|
return fmt.Errorf("%w: %w", ErrInvalidInput, err)
|
|
}
|
|
if err := cfg.Containers.ValidateCredentialBindings(); err != nil {
|
|
return fmt.Errorf("%w: %w", ErrInvalidInput, err)
|
|
}
|
|
// A registry credential must set both engine and key, or neither.
|
|
if ref := cfg.Containers.RegistryAuth; ref != (config.SecretRef{}) && (ref.Engine == "" || ref.Key == "") {
|
|
return fmt.Errorf("%w: containers.registry_auth must name both an engine and a key, got {engine: %q, key: %q}", ErrInvalidInput, ref.Engine, ref.Key)
|
|
}
|
|
return validateBindingKeyEngines(cfg.Bindings)
|
|
}
|
|
|
|
// validateBindingKeyEngines requires the bindings encryption keys to name the
|
|
// env engine. The State Store resolves them at boot, before it serves the
|
|
// installed packages an extension engine comes from, so an extension engine
|
|
// could never answer.
|
|
func validateBindingKeyEngines(b config.BindingsConfig) error {
|
|
refs := append([]config.SecretRef{b.EncryptionKey}, b.PreviousEncryptionKeys...)
|
|
for _, ref := range refs {
|
|
if ref != (config.SecretRef{}) && ref.Engine != "env" {
|
|
return fmt.Errorf("%w: bindings encryption keys must use the env engine, got engine %q", ErrInvalidInput, ref.Engine)
|
|
}
|
|
}
|
|
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") }
|