package config import ( "fmt" "io" "log/slog" "os" "path/filepath" "strings" ) // SettingsFile is de web-instellingen onder state_path. const SettingsFile = "settings.yml" // ImportMarker wordt gezet na een eenmalige import van config.yml. const ImportMarker = "config.yml.imported" // Runtime is de geladen machineconfiguratie plus herkomst. type Runtime struct { Config Config ConfigPath string SettingsPath string Imported bool } // LoadRuntime leest config.yml (als die er is) en overlays settings.yml. // // Veiligheid bij een self-update: // - config.yml wordt nooit herschreven of verwijderd. // - Zonder settings.yml start de server precies zoals Load(config.yml). // - Een bestaande config.yml wordt één keer naar settings.yml gekopieerd // (idempotent via de marker of het bestaan van settings.yml). // - Is settings.yml onleesbaar of ongeldig, dan valt de server terug op // config.yml en start gewoon. // - Omgevingsvariabelen (BLUEGIT_LISTEN, BLUEGIT_AUTH_CLIENT_SECRET, …) // winnen altijd, als laatste redmiddel voor beheer. func LoadRuntime(configPath string, log *slog.Logger) (Runtime, error) { if log == nil { log = slog.New(slog.NewTextHandler(io.Discard, nil)) } rt := Runtime{ConfigPath: configPath} baseline, haveFile, fileErr := loadBaseline(configPath) if !haveFile { baseline.applyDefaults() applyEnv(&baseline) _ = fillSecretFromFile(&baseline) } if imported, err := ImportLegacy(configPath, baseline, log); err != nil { log.Error("config.yml-import naar settings.yml mislukt; bestaande config blijft gelden", "err", err) } else { rt.Imported = imported } rt.SettingsPath = filepath.Join(baseline.StatePath, SettingsFile) result := baseline if set, err := LoadSettings(baseline.StatePath); err != nil { log.Error("settings.yml onleesbaar; val terug op config.yml", "path", rt.SettingsPath, "err", err) } else if set != nil { over := baseline applyPersisted(&over, set) applyEnv(&over) if err := fillSecretFromFile(&over); err != nil && over.Auth.ClientSecret == "" { log.Warn("client_secret_file niet leesbaar; er is mogelijk een geheim in settings.yml of de omgeving", "err", err) } if err := over.Validate(); err != nil { log.Error("settings.yml ongeldig; val terug op config.yml", "err", err) } else { result = over } } if err := result.Validate(); err != nil { if fileErr != nil { return Runtime{}, fileErr } return Runtime{}, err } rt.Config = result return rt, nil } func loadBaseline(configPath string) (Config, bool, error) { if strings.TrimSpace(configPath) == "" { return Config{}, false, nil } st, err := os.Stat(configPath) if err != nil { if os.IsNotExist(err) { return Config{}, false, nil } return Config{}, false, err } if st.IsDir() { return Config{}, false, fmt.Errorf("config: %s is een map", configPath) } c, err := Load(configPath) if err != nil { return Config{}, false, err } return c, true, nil } // ImportLegacy kopieert één keer een bestaande config.yml naar settings.yml. // config.yml zelf blijft ongewijzigd. Idempotent: bestaat settings.yml of // de marker al, dan gebeurt er niets. func ImportLegacy(configPath string, src Config, log *slog.Logger) (bool, error) { if strings.TrimSpace(src.StatePath) == "" { return false, nil } if err := os.MkdirAll(src.StatePath, 0o750); err != nil { return false, err } setPath := filepath.Join(src.StatePath, SettingsFile) markPath := filepath.Join(src.StatePath, ImportMarker) if _, err := os.Stat(setPath); err == nil { _ = touchMarker(markPath) return false, nil } if _, err := os.Stat(markPath); err == nil { return false, nil } if strings.TrimSpace(configPath) == "" { return false, nil } if _, err := os.Stat(configPath); err != nil { return false, nil } if err := SaveSettings(src.StatePath, persistFrom(src)); err != nil { return false, err } if err := touchMarker(markPath); err != nil { return false, err } if log != nil { log.Info("config.yml eenmalig overgenomen in settings.yml; daarna wint de webinterface, config.yml blijft als terugval en is niet meer nodig om te wijzigen", "config", configPath, "settings", setPath) } return true, nil } func touchMarker(path string) error { f, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY, 0o640) if err != nil { return err } return f.Close() } // atomicWrite schrijft path via een tijdelijk bestand in dezelfde map. func atomicWrite(path string, data []byte, mode os.FileMode) error { dir := filepath.Dir(path) if err := os.MkdirAll(dir, 0o750); err != nil { return err } f, err := os.CreateTemp(dir, ".settings-*.tmp") if err != nil { return err } tmp := f.Name() ok := false defer func() { if !ok { _ = os.Remove(tmp) } }() if _, err := f.Write(data); err != nil { _ = f.Close() return err } if err := f.Chmod(mode); err != nil { _ = f.Close() return err } if err := f.Sync(); err != nil { _ = f.Close() return err } if err := f.Close(); err != nil { return err } if err := os.Rename(tmp, path); err != nil { return err } ok = true return nil }