// Package runnercfg is de beheerbare configuratie van een runner: de // aparte bluegit-runner en de ingebouwde BlueGit-runner (Steve) delen // dezelfde instellingen, hardware-aanbevelingen, image-presets, pauze // (drain) en het overzicht van actieve jobs. De webinterface van beide // gebruikt het HTML-fragment uit ui.go. package runnercfg import ( "encoding/json" "errors" "fmt" "os" "path/filepath" "regexp" "sort" "strings" "sync" "gitlab.com/Timfa/bluegit/internal/images" ) // Pull-policy's voor gewone images (presets worden altijd lokaal gebouwd). const ( PullIfNotPresent = "if-not-present" PullAlways = "always" PullNever = "never" ) // Preset is een eigen image-template: óf een vast image, óf een Dockerfile // (met optioneel een ander basis-image). Naam zoals team/tools. type Preset struct { Name string `json:"name"` Image string `json:"image,omitempty"` Dockerfile string `json:"dockerfile,omitempty"` From string `json:"from,omitempty"` Note string `json:"note,omitempty"` } // Settings zijn de instellingen die een beheerder in de UI ziet. type Settings struct { Name string `json:"name"` Concurrency int `json:"concurrency"` MaxImages int `json:"max_images"` CPUs float64 `json:"cpus"` // per job; 0 = geen limiet MemoryMB int `json:"memory_mb"` // per job; 0 = geen limiet PidsLimit int `json:"pids_limit"` // per job; 0 = geen limiet MaxDiskGB int `json:"max_disk_gb"` PullPolicy string `json:"pull_policy"` CleanupWork bool `json:"cleanup_work"` PruneDangling bool `json:"prune_dangling"` PruneCacheGB int `json:"prune_cache_gb"` JobTimeoutMin int `json:"job_timeout_min"` // 0 = wat de job/server zegt Labels []string `json:"labels"` Presets []Preset `json:"presets"` Paused bool `json:"paused"` } // Defaults zijn veilige standaardwaarden, ook zonder hardwaredetectie. func Defaults() Settings { return Settings{ Concurrency: 1, MaxImages: 20, MemoryMB: 0, CPUs: 0, PidsLimit: 0, MaxDiskGB: 0, PullPolicy: PullIfNotPresent, CleanupWork: true, PruneDangling: true, PruneCacheGB: 10, } } var labelRE = regexp.MustCompile(`^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,62}$`) var nameRE = regexp.MustCompile(`^[\pL\pN][\pL\pN ._-]{0,62}$`) // Validate geeft een vertaalbare fout (sleutel uit de catalogus rui.err.*). func (s *Settings) Validate() error { s.Name = strings.TrimSpace(s.Name) if s.Name != "" && !nameRE.MatchString(s.Name) { return Err("rui.err.name") } if s.Concurrency < 1 || s.Concurrency > 64 { return Err("rui.err.concurrency") } if s.MaxImages < 1 || s.MaxImages > 1000 { return Err("rui.err.images") } if s.CPUs < 0 || s.CPUs > 512 || s.MemoryMB < 0 || s.PidsLimit < 0 || s.MaxDiskGB < 0 || s.PruneCacheGB < 0 || s.JobTimeoutMin < 0 { return Err("rui.err.limits") } if s.MemoryMB > 0 && s.MemoryMB < 64 { return Err("rui.err.memory") } switch s.PullPolicy { case "": s.PullPolicy = PullIfNotPresent case PullIfNotPresent, PullAlways, PullNever: default: return Err("rui.err.pull") } var labels []string seen := map[string]bool{} for _, l := range s.Labels { l = strings.TrimSpace(l) if l == "" || seen[l] { continue } if !labelRE.MatchString(l) { return Err("rui.err.label", l) } seen[l] = true labels = append(labels, l) } s.Labels = labels names := map[string]bool{} for i := range s.Presets { p := &s.Presets[i] if err := p.Validate(); err != nil { return err } if names[p.Name] { return Err("rui.err.presetDup", p.Name) } names[p.Name] = true } return nil } // Validate keurt één eigen preset goed (dezelfde regels als ci.presets). func (p *Preset) Validate() error { p.Name = strings.TrimSpace(strings.ToLower(p.Name)) p.Image, p.From = strings.TrimSpace(p.Image), strings.TrimSpace(p.From) p.Dockerfile = strings.TrimSpace(strings.ReplaceAll(p.Dockerfile, "\r\n", "\n")) if p.Image == "" && p.Dockerfile == "" && p.From == "" { return Err("rui.err.presetEmpty", p.Name) } if p.Image != "" && (p.Dockerfile != "" || p.From != "") { return Err("rui.err.presetBoth", p.Name) } if p.From != "" && p.Dockerfile == "" && !images.Known(p.Name) { return Err("rui.err.presetFrom", p.Name) } if p.Dockerfile != "" && !strings.Contains(strings.ToUpper(p.Dockerfile), "FROM ") { return Err("rui.err.presetDockerfile", p.Name) } o := images.Override{Image: p.Image, From: p.From} if p.Dockerfile != "" { o.Dockerfile = os.DevNull // bestaat; de echte tekst wordt later weggeschreven } if err := images.ValidateOverride(p.Name, o, images.Known(p.Name)); err != nil { return Err("rui.err.preset", p.Name, err.Error()) } return nil } // RunArgs zijn de extra `docker run`-argumenten voor de limieten per job. func (s Settings) RunArgs() []string { var out []string if s.CPUs > 0 { out = append(out, "--cpus", trimFloat(s.CPUs)) } if s.MemoryMB > 0 { out = append(out, "--memory", fmt.Sprintf("%dm", s.MemoryMB)) } if s.PidsLimit > 0 { out = append(out, "--pids-limit", fmt.Sprint(s.PidsLimit)) } return out } func trimFloat(f float64) string { return strings.TrimRight(strings.TrimRight(fmt.Sprintf("%.2f", f), "0"), ".") } // Overrides schrijft de Dockerfiles van eigen presets naar dir en geeft // de aliassen zoals images.Effective ze wil. base zijn de presets uit de // configuratie (ci.presets); eigen presets uit de UI gaan voor. func (s Settings) Overrides(dir string, base map[string]images.Override) (map[string]images.Override, error) { out := map[string]images.Override{} for k, v := range base { out[k] = v } for _, p := range s.Presets { o := images.Override{Image: p.Image, From: p.From} if p.Dockerfile != "" { pd := filepath.Join(dir, "presets", strings.ReplaceAll(p.Name, "/", "__")) if err := os.MkdirAll(pd, 0o755); err != nil { return nil, err } f := filepath.Join(pd, "Dockerfile") if err := os.WriteFile(f, []byte(p.Dockerfile+"\n"), 0o644); err != nil { return nil, err } o.Dockerfile = f } out[p.Name] = o } return out, nil } // File bewaart Settings als JSON (schrijfbaar door de service, anders dan /etc). type File struct { Path string mu sync.Mutex } // Load leest de instellingen; een ontbrekend bestand geeft def. func (f *File) Load(def Settings) (Settings, error) { f.mu.Lock() defer f.mu.Unlock() b, err := os.ReadFile(f.Path) if errors.Is(err, os.ErrNotExist) { return def, nil } if err != nil { return def, err } s := def if err := json.Unmarshal(b, &s); err != nil { return def, fmt.Errorf("%s: %w", f.Path, err) } return s, nil } // Save schrijft atomair. func (f *File) Save(s Settings) error { f.mu.Lock() defer f.mu.Unlock() sort.SliceStable(s.Presets, func(i, j int) bool { return s.Presets[i].Name < s.Presets[j].Name }) b, err := json.MarshalIndent(s, "", " ") if err != nil { return err } if err := os.MkdirAll(filepath.Dir(f.Path), 0o755); err != nil { return err } tmp := f.Path + ".tmp" if err := os.WriteFile(tmp, b, 0o600); err != nil { return err } return os.Rename(tmp, f.Path) } // Error is een vertaalbare fout; Key staat in de i18n-catalogus. type Error struct { Key string Args []any } func (e Error) Error() string { return e.Key } // Err maakt een Error. func Err(key string, args ...any) error { return Error{Key: key, Args: args} }