BlueGit

timfa bluegit

Files

bluegit / internal / images / preset.go

preset.go

feat: voeg image-presets en een CI-infopagina toe
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
a6677fb6 History
preset.go 8.5 KiB Download Raw
1// Package images zijn de image-aliassen die Steve voor een job bouwt.
2// bluegit/node is geen aparte runner: het is een Dockerfile die bij het
3// eerste gebruik lokaal wordt gebouwd en daarna hergebruikt. Een gewone
4// naam zoals node:22 blijft een gewoon Docker-image.
5package images
6
7import (
8 "context"
9 "crypto/sha256"
10 "embed"
11 "encoding/hex"
12 "fmt"
13 "os"
14 "os/exec"
15 "path/filepath"
16 "regexp"
17 "sort"
18 "strings"
19 "sync"
20)
21
22//go:embed dockerfiles/*/*
23var dockerfiles embed.FS
24
25// builtinOrder is de volgorde op de infopagina.
26var builtinOrder = []string{"base", "node", "python", "go", "rust", "java", "dotnet"}
27
28// Preset is één alias. Direct gezet betekent: gebruik dat image zonder bouw.
29type Preset struct {
30 Name string
31 From string
32 Runtime string
33 Tools []string
34 Dockerfile []byte
35 Direct string
36}
37
38// Override komt uit ci.presets in config.yml.
39type Override struct {
40 Image string
41 Dockerfile string
42 From string
43}
44
45var nameRE = regexp.MustCompile(`^[a-z0-9]+(?:[._-][a-z0-9]+)*(?:/[a-z0-9]+(?:[._-][a-z0-9]+)*)+$`)
46
47// Known zegt of name een ingebouwde alias is.
48func Known(name string) bool {
49 for _, n := range builtinOrder {
50 if "bluegit/"+n == name {
51 return true
52 }
53 }
54 return false
55}
56
57// ValidateOverride keurt één configregel goed.
58// hasBuiltin is waar als name al een ingebouwde alias is; from mag die
59// Dockerfile dan herschrijven.
60func ValidateOverride(name string, o Override, hasBuiltin bool) error {
61 if !nameRE.MatchString(name) {
62 return fmt.Errorf("ci.presets %q: de naam moet een image-alias zijn, zoals team/tools", name)
63 }
64 if o.Image != "" && (o.Dockerfile != "" || o.From != "") {
65 return fmt.Errorf("ci.presets %s: image sluit dockerfile en from uit", name)
66 }
67 if o.Image == "" && o.Dockerfile == "" && o.From == "" {
68 return fmt.Errorf("ci.presets %s: geef image, dockerfile of from", name)
69 }
70 if o.From != "" && o.Dockerfile == "" && o.Image == "" && !hasBuiltin {
71 return fmt.Errorf("ci.presets %s: from hoort bij een ingebouwde preset of een dockerfile", name)
72 }
73 if o.Image != "" && !validRef(o.Image) {
74 return fmt.Errorf("ci.presets %s: image %q is ongeldig", name, o.Image)
75 }
76 if o.From != "" && !validRef(o.From) {
77 return fmt.Errorf("ci.presets %s: from %q is ongeldig", name, o.From)
78 }
79 if o.Dockerfile != "" {
80 if _, err := os.Stat(o.Dockerfile); err != nil {
81 return fmt.Errorf("ci.presets %s: dockerfile %s: %w", name, o.Dockerfile, err)
82 }
83 }
84 return nil
85}
86
87func validRef(s string) bool {
88 return s != "" && strings.TrimSpace(s) == s && !strings.ContainsAny(s, " \t")
89}
90
91// Builtin leest de Dockerfiles die in het binary zitten.
92func Builtin() []Preset {
93 var out []Preset
94 for _, name := range builtinOrder {
95 raw, err := dockerfiles.ReadFile("dockerfiles/" + name + "/Dockerfile")
96 if err != nil {
97 continue
98 }
99 from, runtime, tools, err := ParseDockerfile(raw)
100 if err != nil {
101 continue
102 }
103 out = append(out, Preset{
104 Name: "bluegit/" + name, From: from, Runtime: runtime, Tools: tools, Dockerfile: raw,
105 })
106 }
107 return out
108}
109
110// Effective is de ingebouwde lijst plus de aliassen uit de configuratie.
111// Een bestaande naam wordt vervangen. Nieuwe namen komen er alfabetisch achter.
112func Effective(over map[string]Override) ([]Preset, error) {
113 base := Builtin()
114 index := map[string]int{}
115 for i, p := range base {
116 index[p.Name] = i
117 }
118 var extra []string
119 for name := range over {
120 if _, ok := index[name]; ok {
121 continue
122 }
123 extra = append(extra, name)
124 }
125 sort.Strings(extra)
126 order := make([]string, 0, len(base)+len(extra))
127 for _, p := range base {
128 order = append(order, p.Name)
129 }
130 order = append(order, extra...)
131 out := make([]Preset, 0, len(order))
132 for _, name := range order {
133 o, ok := over[name]
134 if !ok {
135 out = append(out, base[index[name]])
136 continue
137 }
138 cur := Preset{Name: name}
139 if i, known := index[name]; known {
140 cur = base[i]
141 }
142 next, err := apply(cur, o)
143 if err != nil {
144 return nil, err
145 }
146 out = append(out, next)
147 }
148 return out, nil
149}
150
151func apply(base Preset, o Override) (Preset, error) {
152 if err := ValidateOverride(base.Name, o, len(base.Dockerfile) > 0); err != nil {
153 return Preset{}, err
154 }
155 if o.Image != "" {
156 return Preset{Name: base.Name, From: o.Image, Runtime: o.Image, Direct: o.Image}, nil
157 }
158 data := append([]byte(nil), base.Dockerfile...)
159 if o.Dockerfile != "" {
160 raw, err := os.ReadFile(o.Dockerfile)
161 if err != nil {
162 return Preset{}, fmt.Errorf("ci.presets %s: %w", base.Name, err)
163 }
164 data = raw
165 }
166 if len(data) == 0 {
167 return Preset{}, fmt.Errorf("ci.presets %s: geen dockerfile", base.Name)
168 }
169 if o.From != "" {
170 data = rewriteFrom(data, o.From)
171 }
172 from, runtime, tools, err := ParseDockerfile(data)
173 if err != nil {
174 return Preset{}, fmt.Errorf("ci.presets %s: %w", base.Name, err)
175 }
176 return Preset{Name: base.Name, From: from, Runtime: runtime, Tools: tools, Dockerfile: data}, nil
177}
178
179// Find zoekt een exacte alias. node:22 is er geen.
180func Find(set []Preset, image string) (Preset, bool) {
181 image = strings.TrimSpace(image)
182 for _, p := range set {
183 if p.Name == image {
184 return p, true
185 }
186 }
187 return Preset{}, false
188}
189
190// ParseDockerfile leest FROM, een regel "# runtime:" en de pakketten uit apk of apt-get.
191func ParseDockerfile(data []byte) (from, runtime string, tools []string, err error) {
192 sawFrom := false
193 for _, line := range strings.Split(string(data), "\n") {
194 trim := strings.TrimSpace(line)
195 if trim == "" {
196 continue
197 }
198 if strings.HasPrefix(trim, "#") {
199 if rest, ok := strings.CutPrefix(trim, "# runtime:"); ok {
200 runtime = strings.TrimSpace(rest)
201 }
202 continue
203 }
204 if !sawFrom {
205 fields := strings.Fields(trim)
206 if len(fields) < 2 || !strings.EqualFold(fields[0], "FROM") {
207 return "", "", nil, fmt.Errorf("dockerfile moet met FROM beginnen")
208 }
209 from = fields[1]
210 sawFrom = true
211 continue
212 }
213 tools = append(tools, packages(trim)...)
214 }
215 if from == "" {
216 return "", "", nil, fmt.Errorf("dockerfile mist FROM")
217 }
218 if runtime == "" {
219 runtime = from
220 }
221 return from, runtime, tools, nil
222}
223
224func packages(line string) []string {
225 var out []string
226 if i := strings.Index(line, "apk add"); i >= 0 {
227 out = append(out, packageTokens(line[i+len("apk add"):])...)
228 }
229 if i := strings.Index(line, "apt-get install"); i >= 0 {
230 rest := line[i+len("apt-get install"):]
231 if j := strings.Index(rest, "&&"); j >= 0 {
232 rest = rest[:j]
233 }
234 out = append(out, packageTokens(rest)...)
235 }
236 return out
237}
238
239func packageTokens(s string) []string {
240 var out []string
241 for _, f := range strings.Fields(s) {
242 if strings.HasPrefix(f, "-") {
243 continue
244 }
245 out = append(out, f)
246 }
247 return out
248}
249
250func rewriteFrom(data []byte, from string) []byte {
251 lines := strings.Split(string(data), "\n")
252 for i, line := range lines {
253 trim := strings.TrimSpace(line)
254 if trim == "" || strings.HasPrefix(trim, "#") {
255 continue
256 }
257 if strings.HasPrefix(strings.ToUpper(trim), "FROM ") {
258 lines[i] = "FROM " + from
259 }
260 break
261 }
262 return []byte(strings.Join(lines, "\n"))
263}
264
265var (
266 buildMu = sync.Mutex{}
267 buildOf = map[string]*sync.Mutex{}
268)
269
270func lockRef(ref string) func() {
271 buildMu.Lock()
272 m := buildOf[ref]
273 if m == nil {
274 m = &sync.Mutex{}
275 buildOf[ref] = m
276 }
277 buildMu.Unlock()
278 m.Lock()
279 return m.Unlock
280}
281
282// Ensure bouwt de Dockerfile als het resultaat nog niet lokaal staat.
283// De tag is de alias plus een hash van de Dockerfile, zodat een wijziging
284// een nieuwe bouw is en een gelijke Dockerfile de cache raakt.
285func (p Preset) Ensure(ctx context.Context, dockerBin string) (ref string, built bool, err error) {
286 if p.Direct != "" {
287 return p.Direct, false, nil
288 }
289 if len(p.Dockerfile) == 0 {
290 return "", false, fmt.Errorf("preset %s heeft geen dockerfile", p.Name)
291 }
292 sum := sha256.Sum256(p.Dockerfile)
293 ref = p.Name + ":" + hex.EncodeToString(sum[:6])
294 unlock := lockRef(ref)
295 defer unlock()
296 if ok, _ := imageExists(ctx, dockerBin, ref); ok {
297 return ref, false, nil
298 }
299 dir, err := os.MkdirTemp("", "bluegit-preset-")
300 if err != nil {
301 return "", false, err
302 }
303 defer os.RemoveAll(dir)
304 if err := os.WriteFile(filepath.Join(dir, "Dockerfile"), p.Dockerfile, 0o644); err != nil {
305 return "", false, err
306 }
307 cmd := exec.CommandContext(ctx, dockerBin, "build", "-t", ref, dir)
308 out, err := cmd.CombinedOutput()
309 if err != nil {
310 msg := strings.TrimSpace(string(out))
311 if msg == "" {
312 msg = err.Error()
313 }
314 return "", false, fmt.Errorf("%s", msg)
315 }
316 return ref, true, nil
317}
318
319func imageExists(ctx context.Context, dockerBin, ref string) (bool, error) {
320 cmd := exec.CommandContext(ctx, dockerBin, "image", "inspect", "--format", "{{.Id}}", ref)
321 if err := cmd.Run(); err != nil {
322 return false, err
323 }
324 return true, nil
325}