// Package images zijn de image-aliassen die Steve voor een job bouwt. // bluegit/node is geen aparte runner: het is een Dockerfile die bij het // eerste gebruik lokaal wordt gebouwd en daarna hergebruikt. Een gewone // naam zoals node:22 blijft een gewoon Docker-image. package images import ( "context" "crypto/sha256" "embed" "encoding/hex" "fmt" "os" "os/exec" "path/filepath" "regexp" "sort" "strings" "sync" ) //go:embed dockerfiles/*/* var dockerfiles embed.FS // builtinOrder is de volgorde op de infopagina. var builtinOrder = []string{"base", "node", "python", "go", "rust", "java", "dotnet"} // Preset is één alias. Direct gezet betekent: gebruik dat image zonder bouw. type Preset struct { Name string From string Runtime string Tools []string Dockerfile []byte Direct string } // Override komt uit ci.presets in config.yml. type Override struct { Image string Dockerfile string From string } var nameRE = regexp.MustCompile(`^[a-z0-9]+(?:[._-][a-z0-9]+)*(?:/[a-z0-9]+(?:[._-][a-z0-9]+)*)+$`) // Known zegt of name een ingebouwde alias is. func Known(name string) bool { for _, n := range builtinOrder { if "bluegit/"+n == name { return true } } return false } // ValidateOverride keurt één configregel goed. // hasBuiltin is waar als name al een ingebouwde alias is; from mag die // Dockerfile dan herschrijven. func ValidateOverride(name string, o Override, hasBuiltin bool) error { if !nameRE.MatchString(name) { return fmt.Errorf("ci.presets %q: de naam moet een image-alias zijn, zoals team/tools", name) } if o.Image != "" && (o.Dockerfile != "" || o.From != "") { return fmt.Errorf("ci.presets %s: image sluit dockerfile en from uit", name) } if o.Image == "" && o.Dockerfile == "" && o.From == "" { return fmt.Errorf("ci.presets %s: geef image, dockerfile of from", name) } if o.From != "" && o.Dockerfile == "" && o.Image == "" && !hasBuiltin { return fmt.Errorf("ci.presets %s: from hoort bij een ingebouwde preset of een dockerfile", name) } if o.Image != "" && !validRef(o.Image) { return fmt.Errorf("ci.presets %s: image %q is ongeldig", name, o.Image) } if o.From != "" && !validRef(o.From) { return fmt.Errorf("ci.presets %s: from %q is ongeldig", name, o.From) } if o.Dockerfile != "" { if _, err := os.Stat(o.Dockerfile); err != nil { return fmt.Errorf("ci.presets %s: dockerfile %s: %w", name, o.Dockerfile, err) } } return nil } func validRef(s string) bool { return s != "" && strings.TrimSpace(s) == s && !strings.ContainsAny(s, " \t") } // Builtin leest de Dockerfiles die in het binary zitten. func Builtin() []Preset { var out []Preset for _, name := range builtinOrder { raw, err := dockerfiles.ReadFile("dockerfiles/" + name + "/Dockerfile") if err != nil { continue } from, runtime, tools, err := ParseDockerfile(raw) if err != nil { continue } out = append(out, Preset{ Name: "bluegit/" + name, From: from, Runtime: runtime, Tools: tools, Dockerfile: raw, }) } return out } // Effective is de ingebouwde lijst plus de aliassen uit de configuratie. // Een bestaande naam wordt vervangen. Nieuwe namen komen er alfabetisch achter. func Effective(over map[string]Override) ([]Preset, error) { base := Builtin() index := map[string]int{} for i, p := range base { index[p.Name] = i } var extra []string for name := range over { if _, ok := index[name]; ok { continue } extra = append(extra, name) } sort.Strings(extra) order := make([]string, 0, len(base)+len(extra)) for _, p := range base { order = append(order, p.Name) } order = append(order, extra...) out := make([]Preset, 0, len(order)) for _, name := range order { o, ok := over[name] if !ok { out = append(out, base[index[name]]) continue } cur := Preset{Name: name} if i, known := index[name]; known { cur = base[i] } next, err := apply(cur, o) if err != nil { return nil, err } out = append(out, next) } return out, nil } func apply(base Preset, o Override) (Preset, error) { if err := ValidateOverride(base.Name, o, len(base.Dockerfile) > 0); err != nil { return Preset{}, err } if o.Image != "" { return Preset{Name: base.Name, From: o.Image, Runtime: o.Image, Direct: o.Image}, nil } data := append([]byte(nil), base.Dockerfile...) if o.Dockerfile != "" { raw, err := os.ReadFile(o.Dockerfile) if err != nil { return Preset{}, fmt.Errorf("ci.presets %s: %w", base.Name, err) } data = raw } if len(data) == 0 { return Preset{}, fmt.Errorf("ci.presets %s: geen dockerfile", base.Name) } if o.From != "" { data = rewriteFrom(data, o.From) } from, runtime, tools, err := ParseDockerfile(data) if err != nil { return Preset{}, fmt.Errorf("ci.presets %s: %w", base.Name, err) } return Preset{Name: base.Name, From: from, Runtime: runtime, Tools: tools, Dockerfile: data}, nil } // Find zoekt een exacte alias. node:22 is er geen. func Find(set []Preset, image string) (Preset, bool) { image = strings.TrimSpace(image) for _, p := range set { if p.Name == image { return p, true } } return Preset{}, false } // ParseDockerfile leest FROM, een regel "# runtime:" en de pakketten uit apk of apt-get. func ParseDockerfile(data []byte) (from, runtime string, tools []string, err error) { sawFrom := false for _, line := range strings.Split(string(data), "\n") { trim := strings.TrimSpace(line) if trim == "" { continue } if strings.HasPrefix(trim, "#") { if rest, ok := strings.CutPrefix(trim, "# runtime:"); ok { runtime = strings.TrimSpace(rest) } continue } if !sawFrom { fields := strings.Fields(trim) if len(fields) < 2 || !strings.EqualFold(fields[0], "FROM") { return "", "", nil, fmt.Errorf("dockerfile moet met FROM beginnen") } from = fields[1] sawFrom = true continue } tools = append(tools, packages(trim)...) } if from == "" { return "", "", nil, fmt.Errorf("dockerfile mist FROM") } if runtime == "" { runtime = from } return from, runtime, tools, nil } func packages(line string) []string { var out []string if i := strings.Index(line, "apk add"); i >= 0 { out = append(out, packageTokens(line[i+len("apk add"):])...) } if i := strings.Index(line, "apt-get install"); i >= 0 { rest := line[i+len("apt-get install"):] if j := strings.Index(rest, "&&"); j >= 0 { rest = rest[:j] } out = append(out, packageTokens(rest)...) } return out } func packageTokens(s string) []string { var out []string for _, f := range strings.Fields(s) { if strings.HasPrefix(f, "-") { continue } out = append(out, f) } return out } func rewriteFrom(data []byte, from string) []byte { lines := strings.Split(string(data), "\n") for i, line := range lines { trim := strings.TrimSpace(line) if trim == "" || strings.HasPrefix(trim, "#") { continue } if strings.HasPrefix(strings.ToUpper(trim), "FROM ") { lines[i] = "FROM " + from } break } return []byte(strings.Join(lines, "\n")) } var ( buildMu = sync.Mutex{} buildOf = map[string]*sync.Mutex{} ) func lockRef(ref string) func() { buildMu.Lock() m := buildOf[ref] if m == nil { m = &sync.Mutex{} buildOf[ref] = m } buildMu.Unlock() m.Lock() return m.Unlock } // Ensure bouwt de Dockerfile als het resultaat nog niet lokaal staat. // De tag is de alias plus een hash van de Dockerfile, zodat een wijziging // een nieuwe bouw is en een gelijke Dockerfile de cache raakt. func (p Preset) Ensure(ctx context.Context, dockerBin string) (ref string, built bool, err error) { if p.Direct != "" { return p.Direct, false, nil } if len(p.Dockerfile) == 0 { return "", false, fmt.Errorf("preset %s heeft geen dockerfile", p.Name) } sum := sha256.Sum256(p.Dockerfile) ref = p.Name + ":" + hex.EncodeToString(sum[:6]) unlock := lockRef(ref) defer unlock() if ok, _ := imageExists(ctx, dockerBin, ref); ok { return ref, false, nil } dir, err := os.MkdirTemp("", "bluegit-preset-") if err != nil { return "", false, err } defer os.RemoveAll(dir) if err := os.WriteFile(filepath.Join(dir, "Dockerfile"), p.Dockerfile, 0o644); err != nil { return "", false, err } cmd := exec.CommandContext(ctx, dockerBin, "build", "-t", ref, dir) out, err := cmd.CombinedOutput() if err != nil { msg := strings.TrimSpace(string(out)) if msg == "" { msg = err.Error() } return "", false, fmt.Errorf("%s", msg) } return ref, true, nil } func imageExists(ctx context.Context, dockerBin, ref string) (bool, error) { cmd := exec.CommandContext(ctx, dockerBin, "image", "inspect", "--format", "{{.Id}}", ref) if err := cmd.Run(); err != nil { return false, err } return true, nil }