ananke/internal/config/config.go

package config

import (
	"fmt"
	"os"

	"gopkg.in/yaml.v3"
)

type Config struct {
	Kubeconfig          string   `yaml:"kubeconfig"`
	SSHUser             string   `yaml:"ssh_user"`
	IACRepoPath         string   `yaml:"iac_repo_path"`
	ExpectedFluxBranch  string   `yaml:"expected_flux_branch"`
	ControlPlanes       []string `yaml:"control_planes"`
	Workers             []string `yaml:"workers"`
	LocalBootstrapPaths []string `yaml:"local_bootstrap_paths"`
	ExcludedNamespaces  []string `yaml:"excluded_namespaces"`
	Shutdown            Shutdown `yaml:"shutdown"`
	UPS                 UPS      `yaml:"ups"`
	State               State    `yaml:"state"`
}

type Shutdown struct {
	DefaultBudgetSeconds int  `yaml:"default_budget_seconds"`
	SkipEtcdSnapshot     bool `yaml:"skip_etcd_snapshot"`
	SkipDrain            bool `yaml:"skip_drain"`
}

type UPS struct {
	Enabled                 bool    `yaml:"enabled"`
	Provider                string  `yaml:"provider"`
	Target                  string  `yaml:"target"`
	PollSeconds             int     `yaml:"poll_seconds"`
	RuntimeSafetyFactor     float64 `yaml:"runtime_safety_factor"`
	DebounceCount           int     `yaml:"debounce_count"`
	TelemetryTimeoutSeconds int     `yaml:"telemetry_timeout_seconds"`
}

type State struct {
	Dir            string `yaml:"dir"`
	RunHistoryPath string `yaml:"run_history_path"`
	LockPath       string `yaml:"lock_path"`
}

func Load(path string) (Config, error) {
	cfg := defaults()

	b, err := os.ReadFile(path)
	if err != nil {
		return Config{}, fmt.Errorf("read config %s: %w", path, err)
	}
	if err := yaml.Unmarshal(b, &cfg); err != nil {
		return Config{}, fmt.Errorf("decode config %s: %w", path, err)
	}

	cfg.applyDefaults()
	if err := cfg.Validate(); err != nil {
		return Config{}, err
	}
	return cfg, nil
}

func (c Config) Validate() error {
	if len(c.ControlPlanes) == 0 {
		return fmt.Errorf("config.control_planes must not be empty")
	}
	if c.ExpectedFluxBranch == "" {
		return fmt.Errorf("config.expected_flux_branch must not be empty")
	}
	if c.IACRepoPath == "" {
		return fmt.Errorf("config.iac_repo_path must not be empty")
	}
	if c.Shutdown.DefaultBudgetSeconds <= 0 {
		return fmt.Errorf("config.shutdown.default_budget_seconds must be > 0")
	}
	if c.UPS.Enabled {
		if c.UPS.Provider == "" {
			return fmt.Errorf("config.ups.provider must not be empty when ups is enabled")
		}
		if c.UPS.Target == "" {
			return fmt.Errorf("config.ups.target must not be empty when ups is enabled")
		}
	}
	if c.State.RunHistoryPath == "" || c.State.LockPath == "" {
		return fmt.Errorf("config.state.run_history_path and config.state.lock_path must not be empty")
	}
	return nil
}

func defaults() Config {
	c := Config{
		IACRepoPath:        "/opt/titan-iac",
		ExpectedFluxBranch: "main",
		ControlPlanes:      []string{"titan-0a", "titan-0b", "titan-0c"},
		LocalBootstrapPaths: []string{
			"infrastructure/core",
			"infrastructure/sources/helm",
			"infrastructure/metallb",
			"infrastructure/traefik",
			"infrastructure/vault-csi",
			"infrastructure/vault-injector",
			"services/vault",
			"infrastructure/postgres",
			"services/gitea",
		},
		ExcludedNamespaces: []string{
			"kube-system",
			"kube-public",
			"kube-node-lease",
			"flux-system",
			"traefik",
			"metallb-system",
			"cert-manager",
			"longhorn-system",
			"vault",
			"postgres",
			"maintenance",
		},
		Shutdown: Shutdown{
			DefaultBudgetSeconds: 300,
		},
		UPS: UPS{
			Enabled:                 true,
			Provider:                "nut",
			PollSeconds:             5,
			RuntimeSafetyFactor:     1.10,
			DebounceCount:           3,
			TelemetryTimeoutSeconds: 90,
		},
		State: State{
			Dir:            "/var/lib/hecate",
			RunHistoryPath: "/var/lib/hecate/runs.json",
			LockPath:       "/var/lib/hecate/hecate.lock",
		},
	}
	c.applyDefaults()
	return c
}

func (c *Config) applyDefaults() {
	if c.ExpectedFluxBranch == "" {
		c.ExpectedFluxBranch = "main"
	}
	if c.IACRepoPath == "" {
		c.IACRepoPath = "/opt/titan-iac"
	}
	if c.Shutdown.DefaultBudgetSeconds <= 0 {
		c.Shutdown.DefaultBudgetSeconds = 300
	}
	if c.UPS.PollSeconds <= 0 {
		c.UPS.PollSeconds = 5
	}
	if c.UPS.RuntimeSafetyFactor <= 0 {
		c.UPS.RuntimeSafetyFactor = 1.10
	}
	if c.UPS.DebounceCount <= 0 {
		c.UPS.DebounceCount = 3
	}
	if c.UPS.TelemetryTimeoutSeconds <= 0 {
		c.UPS.TelemetryTimeoutSeconds = 90
	}
	if c.State.Dir == "" {
		c.State.Dir = "/var/lib/hecate"
	}
	if c.State.RunHistoryPath == "" {
		c.State.RunHistoryPath = "/var/lib/hecate/runs.json"
	}
	if c.State.LockPath == "" {
		c.State.LockPath = "/var/lib/hecate/hecate.lock"
	}
}