| 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. |
| 5 | package images |
| 6 | |
| 7 | import ( |
| 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/*/* |
| 23 | var dockerfiles embed.FS |
| 24 | |
| 25 | // builtinOrder is de volgorde op de infopagina. |
| 26 | var builtinOrder = []string{"base", "node", "python", "go", "rust", "java", "dotnet"} |
| 27 | |
| 28 | // Preset is één alias. Direct gezet betekent: gebruik dat image zonder bouw. |
| 29 | type 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. |
| 39 | type Override struct { |
| 40 | Image string |
| 41 | Dockerfile string |
| 42 | From string |
| 43 | } |
| 44 | |
| 45 | var 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. |
| 48 | func 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. |
| 60 | func 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 | |
| 87 | func 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. |
| 92 | func 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. |
| 112 | func 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 | |
| 151 | func 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. |
| 180 | func 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. |
| 191 | func 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 | |
| 224 | func 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 | |
| 239 | func 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 | |
| 250 | func 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 | |
| 265 | var ( |
| 266 | buildMu = sync.Mutex{} |
| 267 | buildOf = map[string]*sync.Mutex{} |
| 268 | ) |
| 269 | |
| 270 | func 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. |
| 285 | func (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 | |
| 319 | func 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 | } |