BlueGit

timfa bluegit

Files

bluegit / internal / config / runtime.go

runtime.go

runtime.go 5.0 KiB Download Raw
1package config
2
3import (
4 "fmt"
5 "io"
6 "log/slog"
7 "os"
8 "path/filepath"
9 "strings"
10)
11
12// SettingsFile is de web-instellingen onder state_path.
13const SettingsFile = "settings.yml"
14
15// ImportMarker wordt gezet na een eenmalige import van config.yml.
16const ImportMarker = "config.yml.imported"
17
18// Runtime is de geladen machineconfiguratie plus herkomst.
19type Runtime struct {
20 Config Config
21 ConfigPath string
22 SettingsPath string
23 Imported bool
24}
25
26// LoadRuntime leest config.yml (als die er is) en overlays settings.yml.
27//
28// Veiligheid bij een self-update:
29// - config.yml wordt nooit herschreven of verwijderd.
30// - Zonder settings.yml start de server precies zoals Load(config.yml).
31// - Een bestaande config.yml wordt één keer naar settings.yml gekopieerd
32// (idempotent via de marker of het bestaan van settings.yml).
33// - Is settings.yml onleesbaar of ongeldig, dan valt de server terug op
34// config.yml en start gewoon.
35// - Omgevingsvariabelen (BLUEGIT_LISTEN, BLUEGIT_AUTH_CLIENT_SECRET, …)
36// winnen altijd, als laatste redmiddel voor beheer.
37func LoadRuntime(configPath string, log *slog.Logger) (Runtime, error) {
38 if log == nil {
39 log = slog.New(slog.NewTextHandler(io.Discard, nil))
40 }
41 rt := Runtime{ConfigPath: configPath}
42 baseline, haveFile, fileErr := loadBaseline(configPath)
43 if !haveFile {
44 baseline.applyDefaults()
45 applyEnv(&baseline)
46 _ = fillSecretFromFile(&baseline)
47 }
48
49 if imported, err := ImportLegacy(configPath, baseline, log); err != nil {
50 log.Error("config.yml-import naar settings.yml mislukt; bestaande config blijft gelden", "err", err)
51 } else {
52 rt.Imported = imported
53 }
54
55 rt.SettingsPath = filepath.Join(baseline.StatePath, SettingsFile)
56 result := baseline
57 if set, err := LoadSettings(baseline.StatePath); err != nil {
58 log.Error("settings.yml onleesbaar; val terug op config.yml", "path", rt.SettingsPath, "err", err)
59 } else if set != nil {
60 over := baseline
61 applyPersisted(&over, set)
62 applyEnv(&over)
63 if err := fillSecretFromFile(&over); err != nil && over.Auth.ClientSecret == "" {
64 log.Warn("client_secret_file niet leesbaar; er is mogelijk een geheim in settings.yml of de omgeving", "err", err)
65 }
66 if err := over.Validate(); err != nil {
67 log.Error("settings.yml ongeldig; val terug op config.yml", "err", err)
68 } else {
69 result = over
70 }
71 }
72
73 if err := result.Validate(); err != nil {
74 if fileErr != nil {
75 return Runtime{}, fileErr
76 }
77 return Runtime{}, err
78 }
79 rt.Config = result
80 return rt, nil
81}
82
83func loadBaseline(configPath string) (Config, bool, error) {
84 if strings.TrimSpace(configPath) == "" {
85 return Config{}, false, nil
86 }
87 st, err := os.Stat(configPath)
88 if err != nil {
89 if os.IsNotExist(err) {
90 return Config{}, false, nil
91 }
92 return Config{}, false, err
93 }
94 if st.IsDir() {
95 return Config{}, false, fmt.Errorf("config: %s is een map", configPath)
96 }
97 c, err := Load(configPath)
98 if err != nil {
99 return Config{}, false, err
100 }
101 return c, true, nil
102}
103
104// ImportLegacy kopieert één keer een bestaande config.yml naar settings.yml.
105// config.yml zelf blijft ongewijzigd. Idempotent: bestaat settings.yml of
106// de marker al, dan gebeurt er niets.
107func ImportLegacy(configPath string, src Config, log *slog.Logger) (bool, error) {
108 if strings.TrimSpace(src.StatePath) == "" {
109 return false, nil
110 }
111 if err := os.MkdirAll(src.StatePath, 0o750); err != nil {
112 return false, err
113 }
114 setPath := filepath.Join(src.StatePath, SettingsFile)
115 markPath := filepath.Join(src.StatePath, ImportMarker)
116 if _, err := os.Stat(setPath); err == nil {
117 _ = touchMarker(markPath)
118 return false, nil
119 }
120 if _, err := os.Stat(markPath); err == nil {
121 return false, nil
122 }
123 if strings.TrimSpace(configPath) == "" {
124 return false, nil
125 }
126 if _, err := os.Stat(configPath); err != nil {
127 return false, nil
128 }
129 if err := SaveSettings(src.StatePath, persistFrom(src)); err != nil {
130 return false, err
131 }
132 if err := touchMarker(markPath); err != nil {
133 return false, err
134 }
135 if log != nil {
136 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",
137 "config", configPath, "settings", setPath)
138 }
139 return true, nil
140}
141
142func touchMarker(path string) error {
143 f, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY, 0o640)
144 if err != nil {
145 return err
146 }
147 return f.Close()
148}
149
150// atomicWrite schrijft path via een tijdelijk bestand in dezelfde map.
151func atomicWrite(path string, data []byte, mode os.FileMode) error {
152 dir := filepath.Dir(path)
153 if err := os.MkdirAll(dir, 0o750); err != nil {
154 return err
155 }
156 f, err := os.CreateTemp(dir, ".settings-*.tmp")
157 if err != nil {
158 return err
159 }
160 tmp := f.Name()
161 ok := false
162 defer func() {
163 if !ok {
164 _ = os.Remove(tmp)
165 }
166 }()
167 if _, err := f.Write(data); err != nil {
168 _ = f.Close()
169 return err
170 }
171 if err := f.Chmod(mode); err != nil {
172 _ = f.Close()
173 return err
174 }
175 if err := f.Sync(); err != nil {
176 _ = f.Close()
177 return err
178 }
179 if err := f.Close(); err != nil {
180 return err
181 }
182 if err := os.Rename(tmp, path); err != nil {
183 return err
184 }
185 ok = true
186 return nil
187}