BlueGit

timfa bluegit

Files

bluegit / internal / runnercfg / settings.go

settings.go

settings.go 7.3 KiB Download Raw
1// Package runnercfg is de beheerbare configuratie van een runner: de
2// aparte bluegit-runner en de ingebouwde BlueGit-runner (Steve) delen
3// dezelfde instellingen, hardware-aanbevelingen, image-presets, pauze
4// (drain) en het overzicht van actieve jobs. De webinterface van beide
5// gebruikt het HTML-fragment uit ui.go.
6package runnercfg
7
8import (
9 "encoding/json"
10 "errors"
11 "fmt"
12 "os"
13 "path/filepath"
14 "regexp"
15 "sort"
16 "strings"
17 "sync"
18
19 "gitlab.com/Timfa/bluegit/internal/images"
20)
21
22// Pull-policy's voor gewone images (presets worden altijd lokaal gebouwd).
23const (
24 PullIfNotPresent = "if-not-present"
25 PullAlways = "always"
26 PullNever = "never"
27)
28
29// Preset is een eigen image-template: óf een vast image, óf een Dockerfile
30// (met optioneel een ander basis-image). Naam zoals team/tools.
31type Preset struct {
32 Name string `json:"name"`
33 Image string `json:"image,omitempty"`
34 Dockerfile string `json:"dockerfile,omitempty"`
35 From string `json:"from,omitempty"`
36 Note string `json:"note,omitempty"`
37}
38
39// Settings zijn de instellingen die een beheerder in de UI ziet.
40type Settings struct {
41 Name string `json:"name"`
42 Concurrency int `json:"concurrency"`
43 MaxImages int `json:"max_images"`
44 CPUs float64 `json:"cpus"` // per job; 0 = geen limiet
45 MemoryMB int `json:"memory_mb"` // per job; 0 = geen limiet
46 PidsLimit int `json:"pids_limit"` // per job; 0 = geen limiet
47 MaxDiskGB int `json:"max_disk_gb"`
48 PullPolicy string `json:"pull_policy"`
49 CleanupWork bool `json:"cleanup_work"`
50 PruneDangling bool `json:"prune_dangling"`
51 PruneCacheGB int `json:"prune_cache_gb"`
52 JobTimeoutMin int `json:"job_timeout_min"` // 0 = wat de job/server zegt
53 Labels []string `json:"labels"`
54 Presets []Preset `json:"presets"`
55 Paused bool `json:"paused"`
56}
57
58// Defaults zijn veilige standaardwaarden, ook zonder hardwaredetectie.
59func Defaults() Settings {
60 return Settings{
61 Concurrency: 1, MaxImages: 20, MemoryMB: 0, CPUs: 0, PidsLimit: 0,
62 MaxDiskGB: 0, PullPolicy: PullIfNotPresent, CleanupWork: true,
63 PruneDangling: true, PruneCacheGB: 10,
64 }
65}
66
67var labelRE = regexp.MustCompile(`^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,62}$`)
68var nameRE = regexp.MustCompile(`^[\pL\pN][\pL\pN ._-]{0,62}$`)
69
70// Validate geeft een vertaalbare fout (sleutel uit de catalogus rui.err.*).
71func (s *Settings) Validate() error {
72 s.Name = strings.TrimSpace(s.Name)
73 if s.Name != "" && !nameRE.MatchString(s.Name) {
74 return Err("rui.err.name")
75 }
76 if s.Concurrency < 1 || s.Concurrency > 64 {
77 return Err("rui.err.concurrency")
78 }
79 if s.MaxImages < 1 || s.MaxImages > 1000 {
80 return Err("rui.err.images")
81 }
82 if s.CPUs < 0 || s.CPUs > 512 || s.MemoryMB < 0 || s.PidsLimit < 0 || s.MaxDiskGB < 0 || s.PruneCacheGB < 0 || s.JobTimeoutMin < 0 {
83 return Err("rui.err.limits")
84 }
85 if s.MemoryMB > 0 && s.MemoryMB < 64 {
86 return Err("rui.err.memory")
87 }
88 switch s.PullPolicy {
89 case "":
90 s.PullPolicy = PullIfNotPresent
91 case PullIfNotPresent, PullAlways, PullNever:
92 default:
93 return Err("rui.err.pull")
94 }
95 var labels []string
96 seen := map[string]bool{}
97 for _, l := range s.Labels {
98 l = strings.TrimSpace(l)
99 if l == "" || seen[l] {
100 continue
101 }
102 if !labelRE.MatchString(l) {
103 return Err("rui.err.label", l)
104 }
105 seen[l] = true
106 labels = append(labels, l)
107 }
108 s.Labels = labels
109 names := map[string]bool{}
110 for i := range s.Presets {
111 p := &s.Presets[i]
112 if err := p.Validate(); err != nil {
113 return err
114 }
115 if names[p.Name] {
116 return Err("rui.err.presetDup", p.Name)
117 }
118 names[p.Name] = true
119 }
120 return nil
121}
122
123// Validate keurt één eigen preset goed (dezelfde regels als ci.presets).
124func (p *Preset) Validate() error {
125 p.Name = strings.TrimSpace(strings.ToLower(p.Name))
126 p.Image, p.From = strings.TrimSpace(p.Image), strings.TrimSpace(p.From)
127 p.Dockerfile = strings.TrimSpace(strings.ReplaceAll(p.Dockerfile, "\r\n", "\n"))
128 if p.Image == "" && p.Dockerfile == "" && p.From == "" {
129 return Err("rui.err.presetEmpty", p.Name)
130 }
131 if p.Image != "" && (p.Dockerfile != "" || p.From != "") {
132 return Err("rui.err.presetBoth", p.Name)
133 }
134 if p.From != "" && p.Dockerfile == "" && !images.Known(p.Name) {
135 return Err("rui.err.presetFrom", p.Name)
136 }
137 if p.Dockerfile != "" && !strings.Contains(strings.ToUpper(p.Dockerfile), "FROM ") {
138 return Err("rui.err.presetDockerfile", p.Name)
139 }
140 o := images.Override{Image: p.Image, From: p.From}
141 if p.Dockerfile != "" {
142 o.Dockerfile = os.DevNull // bestaat; de echte tekst wordt later weggeschreven
143 }
144 if err := images.ValidateOverride(p.Name, o, images.Known(p.Name)); err != nil {
145 return Err("rui.err.preset", p.Name, err.Error())
146 }
147 return nil
148}
149
150// RunArgs zijn de extra `docker run`-argumenten voor de limieten per job.
151func (s Settings) RunArgs() []string {
152 var out []string
153 if s.CPUs > 0 {
154 out = append(out, "--cpus", trimFloat(s.CPUs))
155 }
156 if s.MemoryMB > 0 {
157 out = append(out, "--memory", fmt.Sprintf("%dm", s.MemoryMB))
158 }
159 if s.PidsLimit > 0 {
160 out = append(out, "--pids-limit", fmt.Sprint(s.PidsLimit))
161 }
162 return out
163}
164
165func trimFloat(f float64) string {
166 return strings.TrimRight(strings.TrimRight(fmt.Sprintf("%.2f", f), "0"), ".")
167}
168
169// Overrides schrijft de Dockerfiles van eigen presets naar dir en geeft
170// de aliassen zoals images.Effective ze wil. base zijn de presets uit de
171// configuratie (ci.presets); eigen presets uit de UI gaan voor.
172func (s Settings) Overrides(dir string, base map[string]images.Override) (map[string]images.Override, error) {
173 out := map[string]images.Override{}
174 for k, v := range base {
175 out[k] = v
176 }
177 for _, p := range s.Presets {
178 o := images.Override{Image: p.Image, From: p.From}
179 if p.Dockerfile != "" {
180 pd := filepath.Join(dir, "presets", strings.ReplaceAll(p.Name, "/", "__"))
181 if err := os.MkdirAll(pd, 0o755); err != nil {
182 return nil, err
183 }
184 f := filepath.Join(pd, "Dockerfile")
185 if err := os.WriteFile(f, []byte(p.Dockerfile+"\n"), 0o644); err != nil {
186 return nil, err
187 }
188 o.Dockerfile = f
189 }
190 out[p.Name] = o
191 }
192 return out, nil
193}
194
195// File bewaart Settings als JSON (schrijfbaar door de service, anders dan /etc).
196type File struct {
197 Path string
198 mu sync.Mutex
199}
200
201// Load leest de instellingen; een ontbrekend bestand geeft def.
202func (f *File) Load(def Settings) (Settings, error) {
203 f.mu.Lock()
204 defer f.mu.Unlock()
205 b, err := os.ReadFile(f.Path)
206 if errors.Is(err, os.ErrNotExist) {
207 return def, nil
208 }
209 if err != nil {
210 return def, err
211 }
212 s := def
213 if err := json.Unmarshal(b, &s); err != nil {
214 return def, fmt.Errorf("%s: %w", f.Path, err)
215 }
216 return s, nil
217}
218
219// Save schrijft atomair.
220func (f *File) Save(s Settings) error {
221 f.mu.Lock()
222 defer f.mu.Unlock()
223 sort.SliceStable(s.Presets, func(i, j int) bool { return s.Presets[i].Name < s.Presets[j].Name })
224 b, err := json.MarshalIndent(s, "", " ")
225 if err != nil {
226 return err
227 }
228 if err := os.MkdirAll(filepath.Dir(f.Path), 0o755); err != nil {
229 return err
230 }
231 tmp := f.Path + ".tmp"
232 if err := os.WriteFile(tmp, b, 0o600); err != nil {
233 return err
234 }
235 return os.Rename(tmp, f.Path)
236}
237
238// Error is een vertaalbare fout; Key staat in de i18n-catalogus.
239type Error struct {
240 Key string
241 Args []any
242}
243
244func (e Error) Error() string { return e.Key }
245
246// Err maakt een Error.
247func Err(key string, args ...any) error { return Error{Key: key, Args: args} }