Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 15: Wettkampf – Tool-Challenges auf Zeit

Ziel: Sieben Mini-Tools gegen die Uhr bauen – jedes aus einer Spezifikation und vorgegebenen Tests, bis Tests mit -race, go vet und der Linter grün sind · Dauer: ca. 240 min (gern auf zwei Abende verteilt) · Voraussetzung: Tag 14

Briefing

  • Pro Challenge: Spezifikation lesen, Testdatei abtippen, Stoppuhr starten, Code schreiben, bis ziel grün meldet.
  • Die Tests sind der Schiedsrichter. Ändere sie nicht – außer bei eigenen Tippfehlern.
  • Erst das Paket unter internal/ gegen die Tests, dann cmd/<tool>/main.go nach dem bekannten Muster: dünnes main, run(...) liefert den Exit-Code 0, 1 oder 2 (Tag 6–8).
  • Erlaubt: go doc, Anhang A, deine Tage 1–14. Nur Standardbibliothek.
  • Die Musterlösung liest du erst, wenn du grün bist oder die doppelte Zeit um ist.
 Spezifikation ─► *_test.go abtippen ─► go test: rot ─► Code ─► ziel: grün ─► Zeit
                                           ▲                 │
                                           └──── nachbessern ┘

Startaufstellung

Zwei Shell-Funktionen nehmen dir die Routine ab: start legt Modul, Ordner und Linter-Konfiguration an und startet die Stoppuhr; ziel prüft alles und nennt die Zeit nur, wenn alles grün ist.

cat > ~/go-lab/wettkampf.sh <<'EOF'
# Helfer für Tag 15 – laden mit: source ~/go-lab/wettkampf.sh
start() { # start TOOL PAKET: Modul anlegen und Stoppuhr starten
  mkdir -p ~/go-lab/tag15-"$1"/{cmd/"$1",internal/"$2"} &&
    cd ~/go-lab/tag15-"$1" || return
  [ -f go.mod ] || go mod init example.com/"$1"
  printf 'version: "2"\nlinters:\n  exclusions:\n    presets: [%s]\n' \
    std-error-handling > .golangci.yml
  date +%s > .start
}
ziel() { # ziel: alle Prüfungen; nur wenn alles grün ist, zählt die Zeit
  test -z "$(gofmt -l .)" || { gofmt -l .; return 1; }
  go vet ./... && go test -race -count=1 ./... && ~/go-lab/bin/lint run ./... ||
    return 1
  echo "Zeit: $(( ($(date +%s) - $(cat .start)) / 60 )) min"
}
EOF
source ~/go-lab/wettkampf.sh
command -v start ziel

Erwartet:

start
ziel

Tipp: Funktionen leben nur in der aktuellen Shell. In jedem neuen Terminal zuerst source ~/go-lab/wettkampf.sh.

Challenge 1: portwait – warten mit Backoff

Zeitlimit: 20 min · Punkte: 10 · Bausteine: context, Timer, Funktionstypen (Tag 3, 7)

Spezifikation

  • wait.Backoff(initial, limit, n) liefert die Pause nach Fehlversuch n (ab 0): initial·2^n, höchstens limit – ohne Überlauf, auch bei n = 100.
  • wait.Port(ctx, addr, wait.Options) versucht per Options.Dial (Default: net.Dialer.DialContext) eine TCP-Verbindung, bis es klappt, und liefert die Zahl der Versuche. Defaults: Initial 100 ms, Max 2 s.
  • Nach jedem Fehlversuch ruft Port – falls gesetzt – Options.OnRetry(versuch, err, pause).
  • Endet ctx, kehrt Port sofort zurück; der Fehler enthält context.DeadlineExceeded bzw. context.Canceled (prüfbar mit errors.Is).
  • CLI: portwait [-timeout 30s] [-max 2s] [-v] host:port... mit gemeinsamem Zeitbudget. Exit 0 = alle offen, 1 = Timeout, 2 = falscher Aufruf.

Tests

start portwait wait
cat > internal/wait/wait_test.go <<'EOF'
package wait

import (
    "context"
    "errors"
    "net"
    "slices"
    "syscall"
    "testing"
    "time"
)

func TestBackoff(t *testing.T) {
    ms := time.Millisecond
    tests := []struct {
        n    int
        want time.Duration
    }{
        {0, 100 * ms}, {1, 200 * ms}, {3, 800 * ms}, {4, 1600 * ms},
        {5, 2 * time.Second}, {100, 2 * time.Second}, // 100: kein Überlauf!
    }
    for _, tt := range tests {
        if got := Backoff(100*ms, 2*time.Second, tt.n); got != tt.want {
            t.Errorf("Backoff(n=%d) = %v, will %v", tt.n, got, tt.want)
        }
    }
}

func TestPortOffen(t *testing.T) {
    ln, err := net.Listen("tcp", "127.0.0.1:0")
    if err != nil {
        t.Fatal(err)
    }
    defer ln.Close()
    n, err := Port(context.Background(), ln.Addr().String(), Options{})
    if err != nil || n != 1 {
        t.Errorf("Port = %d, %v; will 1, nil", n, err)
    }
}

func TestPortRetryMitBackoff(t *testing.T) {
    calls := 0
    dial := func(ctx context.Context, _, _ string) (net.Conn, error) {
        calls++
        if calls <= 3 {
            return nil, syscall.ECONNREFUSED
        }
        c1, c2 := net.Pipe()
        c2.Close()
        return c1, nil
    }
    var waits []time.Duration
    o := Options{Initial: time.Millisecond, Max: 3 * time.Millisecond, Dial: dial,
        OnRetry: func(_ int, err error, d time.Duration) {
            if !errors.Is(err, syscall.ECONNREFUSED) {
                t.Errorf("OnRetry err = %v", err)
            }
            waits = append(waits, d)
        }}
    n, err := Port(context.Background(), "lab:1", o)
    if err != nil || n != 4 {
        t.Fatalf("Port = %d, %v; will 4, nil", n, err)
    }
    ms := time.Millisecond
    want := []time.Duration{ms, 2 * ms, 3 * ms} // verdoppelt, dann gedeckelt
    if !slices.Equal(waits, want) {
        t.Errorf("Wartezeiten = %v, will %v", waits, want)
    }
}

func TestPortDeadline(t *testing.T) {
    ln, err := net.Listen("tcp", "127.0.0.1:0")
    if err != nil {
        t.Fatal(err)
    }
    addr := ln.Addr().String()
    ln.Close() // Port ist jetzt zu
    ctx, cancel := context.WithTimeout(context.Background(), 150*time.Millisecond)
    defer cancel()
    start := time.Now()
    _, err = Port(ctx, addr, Options{Initial: 10 * time.Millisecond})
    if !errors.Is(err, context.DeadlineExceeded) {
        t.Errorf("err = %v, will DeadlineExceeded", err)
    }
    if d := time.Since(start); d > time.Second {
        t.Errorf("Abbruch nach %v – context ignoriert?", d)
    }
}
EOF
go test ./internal/wait

Erwartet (gekürzt):

# example.com/portwait/internal/wait [example.com/portwait/internal/wait.test]
internal/wait/wait_test.go:23:13: undefined: Backoff
internal/wait/wait_test.go:35:12: undefined: Port
internal/wait/wait_test.go:35:59: undefined: Options
…
FAIL    example.com/portwait/internal/wait [build failed]

Rot ist der Startschuss. Stoppuhr läuft – ab hier allein weiter.

Musterlösung

cat > internal/wait/wait.go <<'EOF'
// Package wait wartet auf TCP-Ports – mit context und exponentiellem Backoff.
package wait

import (
    "context"
    "fmt"
    "net"
    "time"
)

// Backoff liefert die Pause nach dem Fehlversuch n (ab 0): initial·2^n,
// höchstens limit. Die Schleife verdoppelt nur bis limit – kein Überlauf.
func Backoff(initial, limit time.Duration, n int) time.Duration {
    d := initial
    for range n {
        if d >= limit/2 {
            return limit
        }
        d *= 2
    }
    return min(d, limit)
}

// Options steuert Port. Nullwerte bekommen Defaults.
type Options struct {
    Initial time.Duration // erste Pause, Default 100ms
    Max     time.Duration // längste Pause, Default 2s
    Dial    func(ctx context.Context, network, addr string) (net.Conn, error)
    OnRetry func(attempt int, err error, wait time.Duration) // optional
}

// Port versucht addr zu erreichen, bis es klappt oder ctx endet,
// und liefert die Zahl der Versuche.
func Port(ctx context.Context, addr string, o Options) (int, error) {
    if o.Initial <= 0 {
        o.Initial = 100 * time.Millisecond
    }
    if o.Max <= 0 {
        o.Max = 2 * time.Second
    }
    if o.Dial == nil {
        var d net.Dialer
        o.Dial = d.DialContext
    }
    for attempt := 1; ; attempt++ {
        dctx, cancel := context.WithTimeout(ctx, time.Second) // pro Versuch
        conn, err := o.Dial(dctx, "tcp", addr)
        cancel()
        if err == nil {
            return attempt, conn.Close()
        }
        wait := Backoff(o.Initial, o.Max, attempt-1)
        if o.OnRetry != nil {
            o.OnRetry(attempt, err, wait)
        }
        select {
        case <-ctx.Done():
            return attempt, fmt.Errorf("%s: %w (letzter Fehler: %v)",
                addr, ctx.Err(), err)
        case <-time.After(wait):
        }
    }
}
EOF
cat > cmd/portwait/main.go <<'EOF'
// portwait wartet, bis TCP-Ports offen sind: portwait [-timeout 30s] host:port...
// Tag 15 aus "Go zum Anfassen".
package main

import (
    "context"
    "flag"
    "fmt"
    "io"
    "os"
    "os/signal"
    "time"

    "example.com/portwait/internal/wait"
)

func main() {
    ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
    defer stop()
    os.Exit(run(ctx, os.Args[1:], os.Stdout, os.Stderr))
}

func run(ctx context.Context, args []string, stdout, stderr io.Writer) int {
    fl := flag.NewFlagSet("portwait", flag.ContinueOnError)
    fl.SetOutput(stderr)
    timeout := fl.Duration("timeout", 30*time.Second, "Gesamtbudget für alle Ports")
    maxWait := fl.Duration("max", 2*time.Second, "längste Pause zwischen Versuchen")
    verbose := fl.Bool("v", false, "jeden Fehlversuch melden")
    if err := fl.Parse(args); err != nil {
        return 2
    }
    if fl.NArg() == 0 {
        fmt.Fprintln(stderr, "Aufruf: portwait [-timeout 30s] [-v] host:port...")
        return 2
    }
    ctx, cancel := context.WithTimeout(ctx, *timeout)
    defer cancel()

    o := wait.Options{Max: *maxWait}
    if *verbose {
        o.OnRetry = func(n int, err error, d time.Duration) {
            fmt.Fprintf(stderr, "  Versuch %d: %v (warte %v)\n", n, err, d)
        }
    }
    start := time.Now()
    for _, addr := range fl.Args() {
        n, err := wait.Port(ctx, addr, o)
        if err != nil {
            fmt.Fprintln(stderr, "portwait:", err)
            return 1
        }
        fmt.Fprintf(stdout, "✔ %s offen (%d Versuche, %v)\n", addr, n,
            time.Since(start).Round(time.Millisecond))
    }
    return 0
}
EOF
ziel

Erwartet (Zeit bei dir anders):

?       example.com/portwait/cmd/portwait   [no test files]
ok      example.com/portwait/internal/wait  1.327s
0 issues.
Zeit: 17 min

Warum? Backoff prüft vor dem Verdoppeln, ob limit erreicht ist – initial << n wäre bei n = 100 längst übergelaufen (Tag 4). Das select auf ctx.Done() und time.After bricht auch mitten in einer Pause ab. Der Test ersetzt Dial durch eine Funktion, die dreimal ECONNREFUSED liefert: kein Netz, keine Wartezeit, deterministisch.

go build -o bin/portwait ./cmd/portwait
(sleep 2; python3 -m http.server 8099 --bind 127.0.0.1 >/dev/null 2>&1) &
./bin/portwait -v 127.0.0.1:8099; echo "exit=$?"
pkill -f 'http.server 8099'
./bin/portwait -timeout 1s 127.0.0.1:8099; echo "exit=$?"

Erwartet (gekürzt, Zeiten variieren):

  Versuch 1: dial tcp 127.0.0.1:8099: connect: connection refused (warte 100ms)
  Versuch 2: dial tcp 127.0.0.1:8099: connect: connection refused (warte 200ms)
  …
  Versuch 5: dial tcp 127.0.0.1:8099: connect: connection refused (warte 1.6s)
✔ 127.0.0.1:8099 offen (6 Versuche, 3.105s)
exit=0
portwait: 127.0.0.1:8099: context deadline exceeded (letzter Fehler: dial tcp …
exit=1

Das ist waitport aus der Challenge von Tag 3, erwachsen geworden: Gesamtbudget per context wie in ghrel (Tag 7), Backoff statt fester Pause, -v zeigt jeden Versuch.

Fortschritt speichern? Kostenlos registrieren

Challenge 2: dupfind – Duplikate per SHA-256

Zeitlimit: 30 min · Punkte: 15 · Bausteine: WalkDir, Worker-Pool, Maps (Tag 6, 8)

Spezifikation

  • dup.Find(ctx, root, workers) durchsucht root rekursiv und liefert []dup.Group{Size, Hash, Paths} für Dateien mit identischem Inhalt.
  • Nur reguläre Dateien mit mehr als 0 Byte; Symlinks und leere Dateien zählen nicht. Gehasht wird nur, wessen Größe mehrfach vorkommt.
  • SHA-256 als Hex-String, Paths sortiert. Gruppen sortiert nach Wasted() (Größe × Anzahl Kopien) absteigend, dann nach erstem Pfad.
  • Hashen mit workers Goroutines; gleiches Ergebnis bei 1 und 8 Workern. Abgebrochener ctx liefert context.Canceled, fehlender Ordner einen Fehler mit os.ErrNotExist.
  • CLI: dupfind [-w N] [-json] ORDNER, Default für -w ist die Zahl der CPU-Kerne. Exit 0 = gelaufen (auch mit Funden), 1 = Fehler, 2 = Aufruf.

Tests

start dupfind dup
cat > internal/dup/dup_test.go <<'EOF'
package dup

import (
    "context"
    "errors"
    "os"
    "path/filepath"
    "reflect"
    "testing"
)

// tree legt Dateien relativ zu einem TempDir an und liefert dessen Pfad.
func tree(t *testing.T, files map[string]string) string {
    t.Helper()
    root := t.TempDir()
    for name, content := range files {
        p := filepath.Join(root, name)
        if err := os.MkdirAll(filepath.Dir(p), 0o755); err != nil {
            t.Fatal(err)
        }
        if err := os.WriteFile(p, []byte(content), 0o644); err != nil {
            t.Fatal(err)
        }
    }
    return root
}

func TestFind(t *testing.T) {
    root := tree(t, map[string]string{
        "a.txt":     "hallo",
        "sub/b.txt": "hallo",  // Duplikat von a.txt
        "c.txt":     "hallx",  // gleiche Größe, anderer Inhalt
        "d.txt":     "hallo!", // andere Größe
        "leer1":     "",       // leere Dateien zählen nicht
        "leer2":     "",
    })
    if err := os.Symlink("a.txt", filepath.Join(root, "link")); err != nil {
        t.Fatal(err)
    }
    for _, workers := range []int{1, 8} {
        got, err := Find(context.Background(), root, workers)
        if err != nil {
            t.Fatal(err)
        }
        want := []Group{{
            Size: 5,
            Hash: "d3751d33f9cd5049c4af2b462735457e4d3baf130bcbb87f389e349fbaeb20b9",
            Paths: []string{filepath.Join(root, "a.txt"),
                filepath.Join(root, "sub", "b.txt")},
        }}
        if !reflect.DeepEqual(got, want) {
            t.Errorf("workers=%d:\n got %+v\nwant %+v", workers, got, want)
        }
    }
}

func TestFindSortierung(t *testing.T) {
    root := tree(t, map[string]string{
        "k1": "kurz", "k2": "kurz",
        "l1": "deutlich länger", "l2": "deutlich länger", "l3": "deutlich länger",
    })
    got, err := Find(context.Background(), root, 4)
    if err != nil {
        t.Fatal(err)
    }
    if len(got) != 2 || len(got[0].Paths) != 3 || got[0].Wasted() != 2*16 {
        t.Errorf("größte Verschwendung zuerst erwartet: %+v", got)
    }
}

func TestFindAbbruch(t *testing.T) {
    root := tree(t, map[string]string{"a": "x", "b": "x"})
    ctx, cancel := context.WithCancel(context.Background())
    cancel()
    if _, err := Find(ctx, root, 2); !errors.Is(err, context.Canceled) {
        t.Errorf("err = %v, will context.Canceled", err)
    }
}

func TestFindFehlenderOrdner(t *testing.T) {
    _, err := Find(context.Background(), "/gibt/es/nicht", 2)
    if !errors.Is(err, os.ErrNotExist) {
        t.Errorf("err = %v, will os.ErrNotExist", err)
    }
}
EOF

Musterlösung

cat > internal/dup/dup.go <<'EOF'
// Package dup findet doppelte Dateien per SHA-256 – mit Worker-Pool.
package dup

import (
    "cmp"
    "context"
    "crypto/sha256"
    "encoding/hex"
    "errors"
    "io"
    "io/fs"
    "os"
    "path/filepath"
    "slices"
    "sync"
)

// Group sind Dateien mit identischem Inhalt.
type Group struct {
    Size  int64
    Hash  string   // SHA-256, hex
    Paths []string // sortiert
}

// Wasted ist der Platz, den die Kopien zusätzlich belegen.
func (g Group) Wasted() int64 { return g.Size * int64(len(g.Paths)-1) }

// Find durchsucht root. Gehasht werden nur Dateien, deren Größe mehrfach vorkommt.
func Find(ctx context.Context, root string, workers int) ([]Group, error) {
    bySize := map[int64][]string{}
    err := filepath.WalkDir(root, func(p string, d fs.DirEntry, err error) error {
        if err != nil {
            return err
        }
        if err := ctx.Err(); err != nil {
            return err
        }
        if !d.Type().IsRegular() { // Ordner, Symlinks, Sockets
            return nil
        }
        info, err := d.Info()
        if err != nil {
            return err
        }
        if info.Size() > 0 {
            bySize[info.Size()] = append(bySize[info.Size()], p)
        }
        return nil
    })
    if err != nil {
        return nil, err
    }

    var paths []string
    for _, ps := range bySize {
        if len(ps) > 1 {
            paths = append(paths, ps...)
        }
    }
    sums, err := hashAll(ctx, paths, workers)
    if err != nil {
        return nil, err
    }

    byHash := map[string]*Group{}
    for i, p := range paths {
        g := byHash[sums[i]]
        if g == nil {
            g = &Group{Hash: sums[i]}
            byHash[sums[i]] = g
        }
        g.Paths = append(g.Paths, p)
    }
    var groups []Group
    for _, g := range byHash {
        if len(g.Paths) < 2 {
            continue
        }
        slices.Sort(g.Paths)
        info, err := os.Stat(g.Paths[0])
        if err != nil {
            return nil, err
        }
        g.Size = info.Size()
        groups = append(groups, *g)
    }
    slices.SortFunc(groups, func(a, b Group) int {
        return cmp.Or(cmp.Compare(b.Wasted(), a.Wasted()),
            cmp.Compare(a.Paths[0], b.Paths[0]))
    })
    return groups, nil
}

// hashAll hasht paths mit workers Goroutines; jeder schreibt nur seinen Index.
func hashAll(ctx context.Context, paths []string, workers int) ([]string, error) {
    sums := make([]string, len(paths))
    errs := make([]error, len(paths))
    jobs := make(chan int)
    var wg sync.WaitGroup
    for range max(workers, 1) {
        wg.Go(func() {
            for i := range jobs {
                sums[i], errs[i] = hashFile(paths[i])
            }
        })
    }
feed:
    for i := range paths {
        select {
        case jobs <- i:
        case <-ctx.Done():
            break feed
        }
    }
    close(jobs)
    wg.Wait()
    if err := ctx.Err(); err != nil {
        return nil, err
    }
    return sums, errors.Join(errs...)
}

func hashFile(path string) (string, error) {
    f, err := os.Open(path)
    if err != nil {
        return "", err
    }
    defer f.Close()
    h := sha256.New()
    if _, err := io.Copy(h, f); err != nil {
        return "", err
    }
    return hex.EncodeToString(h.Sum(nil)), nil
}
EOF
cat > cmd/dupfind/main.go <<'EOF'
// dupfind findet doppelte Dateien: dupfind [-w 8] [-json] ORDNER
// Tag 15 aus "Go zum Anfassen".
package main

import (
    "context"
    "encoding/json"
    "flag"
    "fmt"
    "io"
    "os"
    "os/signal"
    "runtime"

    "example.com/dupfind/internal/dup"
)

func main() {
    ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
    defer stop()
    os.Exit(run(ctx, os.Args[1:], os.Stdout, os.Stderr))
}

func run(ctx context.Context, args []string, stdout, stderr io.Writer) int {
    fl := flag.NewFlagSet("dupfind", flag.ContinueOnError)
    fl.SetOutput(stderr)
    workers := fl.Int("w", runtime.NumCPU(), "parallele Hasher")
    asJSON := fl.Bool("json", false, "JSON-Ausgabe")
    if err := fl.Parse(args); err != nil {
        return 2
    }
    if fl.NArg() != 1 {
        fmt.Fprintln(stderr, "Aufruf: dupfind [-w N] [-json] ORDNER")
        return 2
    }
    groups, err := dup.Find(ctx, fl.Arg(0), *workers)
    if err != nil {
        fmt.Fprintln(stderr, "dupfind:", err)
        return 1
    }
    if *asJSON {
        _ = json.NewEncoder(stdout).Encode(groups)
        return 0
    }
    var wasted int64
    for _, g := range groups {
        fmt.Fprintf(stdout, "%d × %d B  %s\n", len(g.Paths), g.Size, g.Hash[:12])
        for _, p := range g.Paths {
            fmt.Fprintln(stdout, "  "+p)
        }
        wasted += g.Wasted()
    }
    fmt.Fprintf(stdout, "%d Gruppen, %d B verschwendet\n", len(groups), wasted)
    return 0
}
EOF
ziel

Warum? Der Größenfilter spart fast alle Hash-Arbeit: Zwei Dateien unterschiedlicher Größe können nie gleich sein. Im Pool schreibt jeder Worker nur sums[i] und errs[i] – kein Lock nötig (Tag 8). Das Label feed: braucht es, weil ein break im select sonst nur das select verlässt.

go build -o bin/dupfind ./cmd/dupfind
mkdir -p demo/sub && printf 'hallo\n' > demo/a.txt
cp demo/a.txt demo/sub/a-kopie.txt && printf 'anders\n' > demo/b.txt
cp /usr/share/dict/words demo/w1 && cp demo/w1 demo/sub/w2
./bin/dupfind demo; echo "exit=$?"
./bin/dupfind "$(go env GOROOT)/src" | tail -1
./bin/dupfind /nix; echo "exit=$?"

Erwartet (Zahlen für GOROOT je nach Go-Version):

2 × 2493885 B  be41ad97963b
  demo/sub/w2
  demo/w1
2 × 6 B  622cb3371c1a
  demo/a.txt
  demo/sub/a-kopie.txt
2 Gruppen, 2493891 B verschwendet
exit=0
154 Gruppen, 3149665 B verschwendet
dupfind: lstat /nix: no such file or directory
exit=1

Die Wortliste /usr/share/dict/words gibt es auf jedem Mac – ein schneller Weg zu einer großen Datei. In der Go-Quelle selbst stecken 154 Gruppen identischer Dateien, meist Testdaten.

Fortschritt speichern? Kostenlos registrieren

Challenge 3: jsonq – ein Mini-jq

Zeitlimit: 30 min · Punkte: 15 · Bausteine: Parser, Typ-Switch, any, Sentinels, Fuzzing (Tag 3, 4, 6)

Spezifikation

  • query.Eval(v, expr) wertet einen Pfad auf einem Wert aus encoding/json aus (map[string]any, []any, …) und liefert []any.
  • Syntax: . (alles), .key, .a.b, [N], [-1] (vom Ende), [] (alle Elemente; bei Objekten die Werte nach Schlüssel sortiert) – beliebig kombiniert wie .items[].name.
  • Wie jq: .x auf null oder einen fehlenden Schlüssel liefert null, ebenso ein Index außerhalb des Arrays.
  • Fehler: Ausdruck ohne führenden Punkt, leerer Schlüssel, kaputter Index → ErrSyntax; .x auf Zahl/String, [N]/[] auf Nicht-Array → ErrType. Keine Eingabe darf eine Panic auslösen.
  • CLI: jsonq [-r] AUSDRUCK [DATEI], liest stdin ohne Datei, verarbeitet mehrere JSON-Werte hintereinander (JSON Lines), gibt jedes Ergebnis kompakt aus, mit -r Strings ohne Anführungszeichen. Zahlen bleiben exakt (98000000, nicht 9.8e+07). Exit 0 = ok, 1 = Eingabe- oder Typfehler, 2 = Aufruf- oder Syntaxfehler.

Tests

start jsonq query
cat > internal/query/query_test.go <<'EOF'
package query

import (
    "encoding/json"
    "errors"
    "reflect"
    "testing"
)

const doc = `{"name":"shop","items":[{"name":"a","tags":["x"]},
    {"name":"b","price":2}],"meta":null}`

func TestEval(t *testing.T) {
    var v any
    if err := json.Unmarshal([]byte(doc), &v); err != nil {
        t.Fatal(err)
    }
    tests := []struct {
        expr string
        want []any
    }{
        {".", []any{v}},
        {".name", []any{"shop"}},
        {".items[0].name", []any{"a"}},
        {".items[].name", []any{"a", "b"}},
        {".items[-1].price", []any{2.0}},
        {".items[5]", []any{nil}},
        {".fehlt.x", []any{nil}},
        {".meta.x", []any{nil}},
        {".items[].tags[0]", []any{"x", nil}},
        {".items[1][]", []any{"b", 2.0}}, // Objekt: Werte nach Schlüssel sortiert
    }
    for _, tt := range tests {
        t.Run(tt.expr, func(t *testing.T) {
            got, err := Eval(v, tt.expr)
            if err != nil {
                t.Fatal(err)
            }
            if !reflect.DeepEqual(got, tt.want) {
                t.Errorf("got %#v, will %#v", got, tt.want)
            }
        })
    }
}

func TestEvalFehler(t *testing.T) {
    var v any
    if err := json.Unmarshal([]byte(doc), &v); err != nil {
        t.Fatal(err)
    }
    tests := []struct {
        expr string
        want error
    }{
        {"name", ErrSyntax},
        {".a..b", ErrSyntax},
        {".a[x]", ErrSyntax},
        {".a[1", ErrSyntax},
        {".name[0]", ErrType},
        {".name.x", ErrType},
        {".name[]", ErrType},
    }
    for _, tt := range tests {
        if _, err := Eval(v, tt.expr); !errors.Is(err, tt.want) {
            t.Errorf("Eval(%q) err = %v, will %v", tt.expr, err, tt.want)
        }
    }
}

func FuzzEval(f *testing.F) {
    f.Add(".items[].name")
    f.Add(".a[-1][]")
    var v any
    _ = json.Unmarshal([]byte(doc), &v)
    f.Fuzz(func(t *testing.T, expr string) {
        _, _ = Eval(v, expr) // darf Fehler liefern, aber nie paniken
    })
}
EOF

Musterlösung

cat > internal/query/query.go <<'EOF'
// Package query wertet einfache jq-Pfade aus: . .a .a.b .a[0] .a[-1] .a[]
package query

import (
    "errors"
    "fmt"
    "maps"
    "slices"
    "strconv"
    "strings"
)

// Sentinels: Syntaxfehler im Ausdruck bzw. falscher Typ im Dokument.
var (
    ErrSyntax = errors.New("syntaxfehler")
    ErrType   = errors.New("typfehler")
)

type kind int

const (
    field kind = iota // .name
    index             // [N]
    iter              // []
)

type step struct {
    kind kind
    key  string
    n    int
}

// parse zerlegt ".items[0].name" in Schritte.
func parse(expr string) ([]step, error) {
    rest, ok := strings.CutPrefix(expr, ".")
    if !ok {
        return nil, fmt.Errorf("%w: %q muss mit . beginnen", ErrSyntax, expr)
    }
    var steps []step
    for rest != "" {
        switch rest[0] {
        case '[':
            inner, after, ok := strings.Cut(rest[1:], "]")
            if !ok {
                return nil, fmt.Errorf("%w: ] fehlt in %q", ErrSyntax, expr)
            }
            if inner == "" {
                steps = append(steps, step{kind: iter})
            } else {
                n, err := strconv.Atoi(inner)
                if err != nil {
                    return nil, fmt.Errorf("%w: Index %q", ErrSyntax, inner)
                }
                steps = append(steps, step{kind: index, n: n})
            }
            rest = after
        case '.':
            rest = rest[1:]
            if rest == "" || rest[0] == '.' {
                return nil, fmt.Errorf("%w: leerer Schlüssel in %q", ErrSyntax, expr)
            }
        default:
            end := strings.IndexAny(rest, ".[")
            if end < 0 {
                end = len(rest)
            }
            steps = append(steps, step{kind: field, key: rest[:end]})
            rest = rest[end:]
        }
    }
    return steps, nil
}

// Eval wendet expr auf v an (Werte wie von encoding/json: map, slice, ...).
func Eval(v any, expr string) ([]any, error) {
    steps, err := parse(expr)
    if err != nil {
        return nil, err
    }
    cur := []any{v}
    for _, s := range steps {
        var next []any
        for _, x := range cur {
            out, err := apply(x, s)
            if err != nil {
                return nil, err
            }
            next = append(next, out...)
        }
        cur = next
    }
    return cur, nil
}

// apply führt einen Schritt aus. Wie jq: .x auf null oder Fehlendes ist null.
func apply(x any, s step) ([]any, error) {
    switch s.kind {
    case field:
        if x == nil {
            return []any{nil}, nil
        }
        m, ok := x.(map[string]any)
        if !ok {
            return nil, fmt.Errorf("%w: .%s auf %T", ErrType, s.key, x)
        }
        return []any{m[s.key]}, nil
    case index:
        if x == nil {
            return []any{nil}, nil
        }
        a, ok := x.([]any)
        if !ok {
            return nil, fmt.Errorf("%w: [%d] auf %T", ErrType, s.n, x)
        }
        i := s.n
        if i < 0 {
            i += len(a) // [-1] ist das letzte Element
        }
        if i < 0 || i >= len(a) {
            return []any{nil}, nil
        }
        return []any{a[i]}, nil
    }
    switch t := x.(type) { // iter
    case []any:
        return t, nil
    case map[string]any:
        out := make([]any, 0, len(t))
        for _, k := range slices.Sorted(maps.Keys(t)) {
            out = append(out, t[k])
        }
        return out, nil
    }
    return nil, fmt.Errorf("%w: [] auf %T", ErrType, x)
}
EOF
cat > cmd/jsonq/main.go <<'EOF'
// jsonq ist ein Mini-jq: jsonq [-r] AUSDRUCK [DATEI]
// Tag 15 aus "Go zum Anfassen".
package main

import (
    "encoding/json"
    "errors"
    "flag"
    "fmt"
    "io"
    "os"

    "example.com/jsonq/internal/query"
)

func main() {
    os.Exit(run(os.Args[1:], os.Stdin, os.Stdout, os.Stderr))
}

func run(args []string, stdin io.Reader, stdout, stderr io.Writer) int {
    fl := flag.NewFlagSet("jsonq", flag.ContinueOnError)
    fl.SetOutput(stderr)
    raw := fl.Bool("r", false, "Strings ohne Anführungszeichen ausgeben")
    if err := fl.Parse(args); err != nil {
        return 2
    }
    if fl.NArg() < 1 || fl.NArg() > 2 {
        fmt.Fprintln(stderr, "Aufruf: jsonq [-r] AUSDRUCK [DATEI]")
        return 2
    }
    in := stdin
    if fl.NArg() == 2 {
        f, err := os.Open(fl.Arg(1))
        if err != nil {
            fmt.Fprintln(stderr, "jsonq:", err)
            return 1
        }
        defer f.Close()
        in = f
    }

    dec := json.NewDecoder(in)
    dec.UseNumber() // 1000000 bleibt 1000000 statt 1e+06
    enc := json.NewEncoder(stdout)
    enc.SetEscapeHTML(false)
    for { // mehrere JSON-Werte hintereinander (JSON Lines) sind erlaubt
        var v any
        err := dec.Decode(&v)
        if errors.Is(err, io.EOF) {
            return 0
        }
        if err != nil {
            fmt.Fprintln(stderr, "jsonq: Eingabe:", err)
            return 1
        }
        out, err := query.Eval(v, fl.Arg(0))
        if errors.Is(err, query.ErrSyntax) {
            fmt.Fprintln(stderr, "jsonq:", err)
            return 2
        }
        if err != nil {
            fmt.Fprintln(stderr, "jsonq:", err)
            return 1
        }
        for _, x := range out {
            if s, ok := x.(string); ok && *raw {
                fmt.Fprintln(stdout, s)
                continue
            }
            _ = enc.Encode(x)
        }
    }
}
EOF
ziel
go test -run '^$' -fuzz FuzzEval -fuzztime 10s ./internal/query | tail -2

Erwartet (gekürzt):

0 issues.
Zeit: 26 min
PASS
ok      example.com/jsonq/internal/query    11.251s

Warum? Erst zerlegen (parse → []step), dann auswerten: Jeder Schritt macht aus einer Liste von Werten eine neue – so ergibt [] mehrere Ergebnisse, und alle folgenden Schritte laufen automatisch für jedes. dec.UseNumber() hält Zahlen als json.Number statt float64; sonst würde aus 98000000 beim Ausgeben 9.8e+07.

go build -o bin/jsonq ./cmd/jsonq
cat > releases.json <<'EOF'
[{"tag_name":"v2.7.1","prerelease":false,
  "assets":[{"name":"bao_linux_amd64","size":98000000}]},
 {"tag_name":"v2.8.0-rc.1","prerelease":true,"assets":[]}]
EOF
./bin/jsonq -r '.[].tag_name' releases.json
./bin/jsonq '.[0].assets[-1]' releases.json
./bin/jsonq '.[0].assets[0].size' < releases.json
printf '{"msg":"start"}\n{"msg":"kaputt"}\n' | ./bin/jsonq -r .msg
./bin/jsonq '.[0].tag_name[0]' releases.json; echo "exit=$?"
./bin/jsonq 'tag_name' releases.json; echo "exit=$?"
diff <(./bin/jsonq '.[].assets' releases.json) \
  <(jq -c '.[].assets' releases.json) && echo "gleich wie jq"

Erwartet:

v2.7.1
v2.8.0-rc.1
{"name":"bao_linux_amd64","size":98000000}
98000000
start
kaputt
jsonq: typfehler: [0] auf string
exit=1
jsonq: syntaxfehler: "tag_name" muss mit . beginnen
exit=2
gleich wie jq

Ein Unterschied bleibt: encoding/json gibt Map-Schlüssel sortiert aus, jq in der Reihenfolge der Eingabe. Für Vergleiche mit jq nimmst du deshalb jq -S.

Fortschritt speichern? Kostenlos registrieren

Challenge 4: envdiff – .env-Dateien vergleichen, ohne Secrets zu zeigen

Zeitlimit: 20 min · Punkte: 10 · Bausteine: bufio, strings, Maps, Sortieren (Tag 1, 2)

Spezifikation

  • envfile.Parse(r) liest KEY=VALUE-Zeilen: Leerzeilen und #-Kommentare überspringen, export vorn ignorieren, Leerzeichen um = erlauben.
  • Werte in "…" oder '…' verlieren die Quotes und behalten alles dazwischen; ohne Quotes beginnt bei # ein Kommentar.
  • Ungültiger Schlüssel (nicht [A-Za-z_][A-Za-z0-9_]*) oder Zeile ohne =: Fehler mit Zeilennummer (zeile 2: …).
  • envfile.Diff(a, b) liefert []Change{Key, Kind, Old, New} mit Added (+), Removed (-), Changed (~), sortiert nach Schlüssel. envfile.Mask(v) verrät nur die Länge: <6 Zeichen>, leer: "".
  • CLI: envdiff [-show] ALT NEU maskiert Werte, außer mit -show. Exit wie diff: 0 = gleich, 1 = Unterschiede, 2 = Fehler.

Tests

start envdiff envfile
cat > internal/envfile/envfile_test.go <<'EOF'
package envfile

import (
    "reflect"
    "strings"
    "testing"
)

func TestParse(t *testing.T) {
    in := `# Kommentar
APP_ENV=prod

export DB_HOST = db1.lab
DB_PASS="lab pw # kein Kommentar"
TOKEN='sk-lab-1234'
PORT=8080 # Kommentar am Ende
LEER=
URL=https://x.lab/?a=b
`
    got, err := Parse(strings.NewReader(in))
    if err != nil {
        t.Fatal(err)
    }
    want := map[string]string{
        "APP_ENV": "prod", "DB_HOST": "db1.lab", "DB_PASS": "lab pw # kein Kommentar",
        "TOKEN": "sk-lab-1234", "PORT": "8080", "LEER": "", "URL": "https://x.lab/?a=b",
    }
    if !reflect.DeepEqual(got, want) {
        t.Errorf("\n got %q\nwant %q", got, want)
    }
}

func TestParseFehler(t *testing.T) {
    for _, in := range []string{"A=1\nB-C=2\n", "A=1\nnur text\n", "A=1\n1X=2\n"} {
        _, err := Parse(strings.NewReader(in))
        if err == nil || !strings.Contains(err.Error(), "zeile 2") {
            t.Errorf("Parse(%q) err = %v, will Fehler mit zeile 2", in, err)
        }
    }
}

func TestDiff(t *testing.T) {
    a := map[string]string{"A": "1", "B": "2", "C": "3"}
    b := map[string]string{"B": "2", "C": "33", "D": "4"}
    want := []Change{
        {Key: "A", Kind: Removed, Old: "1"},
        {Key: "C", Kind: Changed, Old: "3", New: "33"},
        {Key: "D", Kind: Added, New: "4"},
    }
    if got := Diff(a, b); !reflect.DeepEqual(got, want) {
        t.Errorf("\n got %+v\nwant %+v", got, want)
    }
    if got := Diff(a, a); len(got) != 0 {
        t.Errorf("Diff(a, a) = %+v, will leer", got)
    }
}

func TestMask(t *testing.T) {
    tests := map[string]string{
        "": `""`, "geheim": "<6 Zeichen>", "Grüße": "<5 Zeichen>",
    }
    for in, want := range tests {
        if got := Mask(in); got != want {
            t.Errorf("Mask(%q) = %q, will %q", in, got, want)
        }
    }
}
EOF

Musterlösung

cat > internal/envfile/envfile.go <<'EOF'
// Package envfile liest .env-Dateien und vergleicht sie.
package envfile

import (
    "bufio"
    "fmt"
    "io"
    "maps"
    "regexp"
    "slices"
    "strings"
    "unicode/utf8"
)

var keyRe = regexp.MustCompile(`^[A-Za-z_][A-Za-z0-9_]*$`)

// Parse liest KEY=VALUE-Zeilen mit #-Kommentaren, "export " und Quotes.
// Doppelte Schlüssel: der letzte gewinnt (wie bei source in der Shell).
func Parse(r io.Reader) (map[string]string, error) {
    env := map[string]string{}
    sc := bufio.NewScanner(r)
    for n := 1; sc.Scan(); n++ {
        line := strings.TrimSpace(sc.Text())
        if line == "" || strings.HasPrefix(line, "#") {
            continue
        }
        line = strings.TrimPrefix(line, "export ")
        key, val, ok := strings.Cut(line, "=")
        key, val = strings.TrimSpace(key), strings.TrimSpace(val)
        if !ok || !keyRe.MatchString(key) {
            return nil, fmt.Errorf("zeile %d: erwarte KEY=VALUE, nicht %q", n, line)
        }
        env[key] = value(val)
    }
    return env, sc.Err()
}

// value entfernt Quotes; ohne Quotes beginnt bei " #" ein Kommentar.
func value(v string) string {
    if len(v) >= 2 && (v[0] == '"' || v[0] == '\'') && v[len(v)-1] == v[0] {
        return v[1 : len(v)-1]
    }
    if i := strings.Index(v, " #"); i >= 0 {
        v = strings.TrimSpace(v[:i])
    }
    return v
}

// Kind ist die Art einer Änderung.
type Kind string

const (
    Added   Kind = "+"
    Removed Kind = "-"
    Changed Kind = "~"
)

// Change ist ein Unterschied zwischen zwei Dateien.
type Change struct {
    Key      string
    Kind     Kind
    Old, New string
}

// Diff liefert alle Unterschiede von a nach b, sortiert nach Schlüssel.
func Diff(a, b map[string]string) []Change {
    keys := slices.Sorted(maps.Keys(a))
    for k := range b {
        if _, ok := a[k]; !ok {
            keys = append(keys, k)
        }
    }
    slices.Sort(keys)
    var out []Change
    for _, k := range keys {
        va, inA := a[k]
        vb, inB := b[k]
        switch {
        case !inB:
            out = append(out, Change{Key: k, Kind: Removed, Old: va})
        case !inA:
            out = append(out, Change{Key: k, Kind: Added, New: vb})
        case va != vb:
            out = append(out, Change{Key: k, Kind: Changed, Old: va, New: vb})
        }
    }
    return out
}

// Mask verrät nur die Länge eines Werts – Secrets bleiben unsichtbar.
func Mask(v string) string {
    if v == "" {
        return `""`
    }
    return fmt.Sprintf("<%d Zeichen>", utf8.RuneCountInString(v))
}
EOF
cat > cmd/envdiff/main.go <<'EOF'
// envdiff vergleicht zwei .env-Dateien, ohne Secrets zu zeigen:
// envdiff [-show] ALT NEU. Exit 0 = gleich, 1 = Unterschiede, 2 = Fehler.
// Tag 15 aus "Go zum Anfassen".
package main

import (
    "flag"
    "fmt"
    "io"
    "os"

    "example.com/envdiff/internal/envfile"
)

func main() {
    os.Exit(run(os.Args[1:], os.Stdout, os.Stderr))
}

func run(args []string, stdout, stderr io.Writer) int {
    fl := flag.NewFlagSet("envdiff", flag.ContinueOnError)
    fl.SetOutput(stderr)
    show := fl.Bool("show", false, "Werte im Klartext zeigen (Vorsicht: Secrets!)")
    if err := fl.Parse(args); err != nil {
        return 2
    }
    if fl.NArg() != 2 {
        fmt.Fprintln(stderr, "Aufruf: envdiff [-show] ALT NEU")
        return 2
    }
    var envs [2]map[string]string
    for i, name := range fl.Args() {
        env, err := load(name)
        if err != nil {
            fmt.Fprintln(stderr, "envdiff:", err)
            return 2
        }
        envs[i] = env
    }
    val := envfile.Mask
    if *show {
        val = func(v string) string { return v }
    }
    changes := envfile.Diff(envs[0], envs[1])
    for _, c := range changes {
        switch c.Kind {
        case envfile.Added:
            fmt.Fprintf(stdout, "+ %s=%s\n", c.Key, val(c.New))
        case envfile.Removed:
            fmt.Fprintf(stdout, "- %s\n", c.Key)
        case envfile.Changed:
            fmt.Fprintf(stdout, "~ %s: %s -> %s\n", c.Key, val(c.Old), val(c.New))
        }
    }
    if len(changes) > 0 {
        return 1
    }
    return 0
}

func load(name string) (map[string]string, error) {
    f, err := os.Open(name)
    if err != nil {
        return nil, err
    }
    defer f.Close()
    env, err := envfile.Parse(f)
    if err != nil {
        return nil, fmt.Errorf("%s: %w", name, err)
    }
    return env, nil
}
EOF
ziel

Warum? strings.Cut trennt am ersten =, deshalb bleibt URL=https://x.lab/?a=b heil. Die Fehlermeldung beginnt klein (zeile 2), weil der Linter großgeschriebene Fehlertexte anmahnt (ST1005) – sie werden meist in andere Meldungen eingebettet. In main ist val eine Funktionsvariable: maskieren oder nicht entscheidet eine Zeile, nicht jedes Printf.

go build -o bin/envdiff ./cmd/envdiff
printf 'APP_ENV=staging\nDB_HOST=db1.lab\nDB_PASS=lab-pw-staging\nFEATURE_X=true\n' \
  > staging.env
printf 'APP_ENV=prod\nDB_HOST=db1.lab\nDB_PASS="lab-pw-prod-2026"\nLOG_LEVEL=warn\n' \
  > prod.env
./bin/envdiff staging.env prod.env; echo "exit=$?"
./bin/envdiff -show staging.env prod.env | grep APP_ENV
./bin/envdiff prod.env prod.env; echo "exit=$?"
printf 'A=1\nkaputt\n' > bad.env; ./bin/envdiff prod.env bad.env; echo "exit=$?"

Erwartet:

~ APP_ENV: <7 Zeichen> -> <4 Zeichen>
~ DB_PASS: <14 Zeichen> -> <16 Zeichen>
- FEATURE_X
+ LOG_LEVEL=<4 Zeichen>
exit=1
~ APP_ENV: staging -> prod
exit=0
envdiff: bad.env: zeile 2: erwarte KEY=VALUE, nicht "kaputt"
exit=2

Die Passwörter sind Lab-Werte – trotzdem tauchen sie in der Ausgabe nicht auf. Genau so gehört ein Diff in ein CI-Log.

Fortschritt speichern? Kostenlos registrieren

Challenge 5: certdays – wie lange gilt das Zertifikat noch?

Zeitlimit: 25 min · Punkte: 15 · Bausteine: crypto/x509, crypto/tls, context, httptest (Tag 7, 9)

Spezifikation

  • certs.Days(notAfter, now) liefert die vollen Tage bis zum Ablauf, abgerundet; abgelaufen ist negativ (1 Stunde drüber = -1).
  • certs.FromPEM(name, data, now) liest alle CERTIFICATE-Blöcke (Bundle, Chain) und überspringt andere Blöcke wie Keys. Kein Zertifikat: Fehler mit ErrNoCert.
  • certs.FromAddr(ctx, "host:port", now) holt das Server-Zertifikat per TLS-Handshake – auch abgelaufene oder selbst signierte, denn genau die willst du finden.
  • certs.Info enthält Source, Subject (CN=…), NotAfter, Days.
  • CLI: certdays [-warn 30] [-timeout 5s] ZIEL...; ZIEL ist eine vorhandene Datei oder host:port. Tabelle mit TAGE ABLAUF SUBJECT QUELLE, ✘ unter -warn. Exit 1, wenn eins unter -warn liegt oder nicht lesbar ist; 2 = Aufruf.

Tests

start certdays certs
cat > internal/certs/certs_test.go <<'EOF'
package certs

import (
    "context"
    "crypto/ecdsa"
    "crypto/elliptic"
    "crypto/rand"
    "crypto/x509"
    "crypto/x509/pkix"
    "encoding/pem"
    "errors"
    "math/big"
    "net/http/httptest"
    "strings"
    "testing"
    "time"
)

var now = time.Date(2026, 10, 10, 12, 0, 0, 0, time.UTC)

// selfSigned erzeugt ein Lab-Zertifikat als PEM, gültig bis notAfter.
func selfSigned(t *testing.T, cn string, notAfter time.Time) []byte {
    t.Helper()
    key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
    if err != nil {
        t.Fatal(err)
    }
    tmpl := &x509.Certificate{
        SerialNumber: big.NewInt(1),
        Subject:      pkix.Name{CommonName: cn},
        NotBefore:    now.AddDate(0, -1, 0),
        NotAfter:     notAfter,
    }
    der, err := x509.CreateCertificate(rand.Reader, tmpl, tmpl, &key.PublicKey, key)
    if err != nil {
        t.Fatal(err)
    }
    return pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: der})
}

func TestDays(t *testing.T) {
    tests := []struct {
        notAfter time.Time
        want     int
    }{
        {now.Add(10*24*time.Hour + time.Hour), 10},
        {now.Add(23 * time.Hour), 0},
        {now.Add(-time.Hour), -1}, // abgelaufen: negativ
    }
    for _, tt := range tests {
        if got := Days(tt.notAfter, now); got != tt.want {
            t.Errorf("Days(%v) = %d, will %d", tt.notAfter, got, tt.want)
        }
    }
}

func TestFromPEM(t *testing.T) {
    data := append(selfSigned(t, "a.lab", now.AddDate(0, 0, 30)),
        selfSigned(t, "b.lab", now.Add(-48*time.Hour))...)
    infos, err := FromPEM("bundle.pem", data, now)
    if err != nil {
        t.Fatal(err)
    }
    if len(infos) != 2 {
        t.Fatalf("%d Zertifikate, will 2", len(infos))
    }
    if infos[0].Subject != "CN=a.lab" || infos[0].Days != 30 ||
        infos[1].Days != -2 || infos[1].Source != "bundle.pem" {
        t.Errorf("infos = %+v", infos)
    }
}

func TestFromPEMOhneZertifikat(t *testing.T) {
    _, err := FromPEM("x.pem", []byte("kein PEM"), now)
    if !errors.Is(err, ErrNoCert) {
        t.Errorf("err = %v, will ErrNoCert", err)
    }
}

func TestFromAddr(t *testing.T) {
    srv := httptest.NewTLSServer(nil) // Testzertifikat von Go, lange gültig
    defer srv.Close()
    addr := strings.TrimPrefix(srv.URL, "https://")
    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
    defer cancel()
    infos, err := FromAddr(ctx, addr, now)
    if err != nil {
        t.Fatal(err)
    }
    if len(infos) != 1 || infos[0].Days < 365 || infos[0].Source != addr {
        t.Errorf("infos = %+v", infos)
    }
}
EOF

Der Test erzeugt seine Zertifikate selbst (ECDSA P-256, selbst signiert) – keine Dateien, kein Netz. httptest.NewTLSServer liefert einen echten TLS-Server mit Go-eigenem Testzertifikat.

Musterlösung

cat > internal/certs/certs.go <<'EOF'
// Package certs liest Zertifikate aus PEM-Dateien oder von TLS-Servern
// und berechnet die Resttage.
package certs

import (
    "context"
    "crypto/tls"
    "crypto/x509"
    "encoding/pem"
    "errors"
    "fmt"
    "math"
    "net"
    "time"
)

// ErrNoCert meldet eine Datei ohne CERTIFICATE-Block.
var ErrNoCert = errors.New("kein Zertifikat gefunden")

// Info beschreibt ein Zertifikat.
type Info struct {
    Source   string // Datei oder host:port
    Subject  string
    NotAfter time.Time
    Days     int // volle Tage bis Ablauf, negativ = abgelaufen
}

// Days liefert die vollen Tage von now bis notAfter (abgerundet).
func Days(notAfter, now time.Time) int {
    return int(math.Floor(notAfter.Sub(now).Hours() / 24))
}

func info(src string, c *x509.Certificate, now time.Time) Info {
    return Info{Source: src, Subject: c.Subject.String(), NotAfter: c.NotAfter,
        Days: Days(c.NotAfter, now)}
}

// FromPEM liest alle Zertifikate aus data (z. B. eine Chain oder ein Bundle).
func FromPEM(name string, data []byte, now time.Time) ([]Info, error) {
    var out []Info
    for {
        var b *pem.Block
        b, data = pem.Decode(data)
        if b == nil {
            break
        }
        if b.Type != "CERTIFICATE" {
            continue // z. B. PRIVATE KEY im selben File
        }
        c, err := x509.ParseCertificate(b.Bytes)
        if err != nil {
            return nil, fmt.Errorf("%s: %w", name, err)
        }
        out = append(out, info(name, c, now))
    }
    if len(out) == 0 {
        return nil, fmt.Errorf("%s: %w", name, ErrNoCert)
    }
    return out, nil
}

// FromAddr holt das Server-Zertifikat von addr (host:port).
func FromAddr(ctx context.Context, addr string, now time.Time) ([]Info, error) {
    host, _, err := net.SplitHostPort(addr)
    if err != nil {
        return nil, err
    }
    d := tls.Dialer{Config: &tls.Config{
        ServerName: host,
        // Nur lesen: Auch abgelaufene oder selbst signierte Zertifikate
        // sollen gemeldet werden. Es werden keine Daten gesendet.
        InsecureSkipVerify: true,
    }}
    conn, err := d.DialContext(ctx, "tcp", addr)
    if err != nil {
        return nil, err
    }
    defer conn.Close()
    state := conn.(*tls.Conn).ConnectionState()
    if len(state.PeerCertificates) == 0 {
        return nil, fmt.Errorf("%s: %w", addr, ErrNoCert)
    }
    return []Info{info(addr, state.PeerCertificates[0], now)}, nil
}
EOF
cat > cmd/certdays/main.go <<'EOF'
// certdays zeigt, wie lange Zertifikate noch gültig sind:
// certdays [-warn 30] DATEI.pem|host:port...
// Exit 1, wenn eins unter -warn Tagen liegt oder nicht lesbar ist.
// Tag 15 aus "Go zum Anfassen".
package main

import (
    "context"
    "flag"
    "fmt"
    "io"
    "os"
    "os/signal"
    "text/tabwriter"
    "time"

    "example.com/certdays/internal/certs"
)

func main() {
    ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
    defer stop()
    os.Exit(run(ctx, os.Args[1:], time.Now(), os.Stdout, os.Stderr))
}

func run(ctx context.Context, args []string, now time.Time,
    stdout, stderr io.Writer) int {
    fl := flag.NewFlagSet("certdays", flag.ContinueOnError)
    fl.SetOutput(stderr)
    warn := fl.Int("warn", 30, "Exit 1 unter so vielen Resttagen")
    timeout := fl.Duration("timeout", 5*time.Second, "Timeout pro Server")
    if err := fl.Parse(args); err != nil {
        return 2
    }
    if fl.NArg() == 0 {
        fmt.Fprintln(stderr, "Aufruf: certdays [-warn 30] DATEI.pem|host:port...")
        return 2
    }
    code := 0
    tw := tabwriter.NewWriter(stdout, 0, 4, 2, ' ', 0)
    fmt.Fprintln(tw, "TAGE\tABLAUF\tSUBJECT\tQUELLE")
    for _, target := range fl.Args() {
        infos, err := load(ctx, target, now, *timeout)
        if err != nil {
            fmt.Fprintln(stderr, "certdays:", err)
            code = 1
            continue
        }
        for _, i := range infos {
            mark := ""
            if i.Days < *warn {
                mark, code = " ✘", 1
            }
            fmt.Fprintf(tw, "%d%s\t%s\t%s\t%s\n", i.Days, mark,
                i.NotAfter.Format(time.DateOnly), i.Subject, i.Source)
        }
    }
    _ = tw.Flush()
    return code
}

// load nimmt eine vorhandene Datei als PEM, alles andere als host:port.
func load(ctx context.Context, target string, now time.Time,
    timeout time.Duration) ([]certs.Info, error) {
    if data, err := os.ReadFile(target); err == nil {
        return certs.FromPEM(target, data, now)
    }
    ctx, cancel := context.WithTimeout(ctx, timeout)
    defer cancel()
    return certs.FromAddr(ctx, target, now)
}
EOF
ziel

Warum? now ist ein Parameter statt time.Now() im Paket – nur so sind die Tests reproduzierbar. math.Floor rundet auch negative Werte nach unten; ein int(...) allein würde -0,04 Tage zu 0 machen und ein abgelaufenes Zertifikat als gültig melden.

Sicherheit: InsecureSkipVerify ist hier vertretbar, weil das Tool nur das Zertifikat liest und keine Daten sendet. In jedem Client, der Daten austauscht, ist es tabu (Tag 8, Enterprise-Notiz).

go build -o bin/certdays ./cmd/certdays
openssl req -x509 -newkey ec -pkeyopt ec_paramgen_curve:prime256v1 -nodes \
  -days 7 -subj /CN=lab.local -keyout /dev/null -out lab.pem 2>/dev/null
./bin/certdays lab.pem go.dev:443 kubernetes.io:443; echo "exit=$?"
./bin/certdays -warn 3 lab.pem; echo "exit=$?"
./bin/certdays -timeout 1s 127.0.0.1:1 go.mod; echo "exit=$?"

Erwartet (gekürzt, Daten ändern sich):

TAGE  ABLAUF      SUBJECT           QUELLE
6 ✘   2026-10-17  CN=lab.local      lab.pem
70    2026-12-20  CN=go.dev         go.dev:443
31    2026-11-10  CN=kubernetes.io  kubernetes.io:443
exit=1
TAGE  ABLAUF      SUBJECT       QUELLE
6     2026-10-17  CN=lab.local  lab.pem
exit=0
certdays: dial tcp 127.0.0.1:1: connect: connection refused
certdays: go.mod: kein Zertifikat gefunden
TAGE  ABLAUF  SUBJECT  QUELLE
exit=1

Sieben Tage ausgestellt, sechs gemeldet: Das Zertifikat ist schon einige Sekunden alt, und Days rundet ab. Für Alarme ist das die richtige Richtung.

Fortschritt speichern? Kostenlos registrieren

Challenge 6: logtail – tail -F ohne fsnotify

Zeitlimit: 30 min · Punkte: 15 · Bausteine: io, os.FileInfo, Ticker, context, Race-Detector (Tag 6, 8)

Spezifikation

  • tail.Last(path, n) liefert die letzten n Zeilen und das Byte-Offset dahinter – mit konstantem Speicher, auch bei großen Dateien.
  • tail.Follow(ctx, path, off, every, out) prüft alle every die Datei und schreibt jede neue, vollständige Zeile (mit \n) nach out. Eine halbe Zeile wartet, bis ihr Rest da ist.
  • Truncate (Datei kleiner als das Offset, z. B. logrotate mit copytruncate): von vorn lesen.
  • Rotation (unter dem Namen liegt eine andere Datei, os.SameFile): erst den Rest der alten Datei lesen, dann die neue von Anfang an.
  • Endet ctx, gibt Follow nil zurück. CLI: logtail [-n 10] [-i 250ms] DATEI, Strg+C oder SIGTERM beendet mit Exit 0, Fehler 1, Aufruf 2.

Tests

start logtail tail
cat > internal/tail/tail_test.go <<'EOF'
package tail

import (
    "bytes"
    "context"
    "os"
    "path/filepath"
    "slices"
    "strings"
    "sync"
    "testing"
    "time"
)

// syncBuf ist ein Writer, den Test und Follow-Goroutine gefahrlos teilen.
type syncBuf struct {
    mu sync.Mutex
    b  bytes.Buffer
}

func (s *syncBuf) Write(p []byte) (int, error) {
    s.mu.Lock()
    defer s.mu.Unlock()
    return s.b.Write(p)
}

func (s *syncBuf) String() string {
    s.mu.Lock()
    defer s.mu.Unlock()
    return s.b.String()
}

// waitFor wartet bis zu 2 s, bis out mit suffix endet.
func waitFor(t *testing.T, out *syncBuf, suffix string) {
    t.Helper()
    for range 200 {
        if strings.HasSuffix(out.String(), suffix) {
            return
        }
        time.Sleep(10 * time.Millisecond)
    }
    t.Fatalf("Ausgabe endet nicht mit %q:\n%s", suffix, out.String())
}

func appendTo(t *testing.T, path, s string) {
    t.Helper()
    f, err := os.OpenFile(path, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0o644)
    if err != nil {
        t.Fatal(err)
    }
    defer f.Close()
    if _, err := f.WriteString(s); err != nil {
        t.Fatal(err)
    }
}

func TestLast(t *testing.T) {
    path := filepath.Join(t.TempDir(), "app.log")
    appendTo(t, path, "a\nb\nc\nd\ne\n")
    lines, off, err := Last(path, 3)
    if err != nil {
        t.Fatal(err)
    }
    if !slices.Equal(lines, []string{"c", "d", "e"}) || off != 10 {
        t.Errorf("Last = %q, %d; will [c d e], 10", lines, off)
    }
}

func TestFollow(t *testing.T) {
    path := filepath.Join(t.TempDir(), "app.log")
    appendTo(t, path, "alt\n")
    ctx, cancel := context.WithCancel(context.Background())
    out := &syncBuf{}
    done := make(chan error, 1)
    go func() { done <- Follow(ctx, path, 4, 10*time.Millisecond, out) }()

    appendTo(t, path, "eins\nzw")
    time.Sleep(50 * time.Millisecond) // halbe Zeile darf noch nicht erscheinen
    if got := out.String(); got != "eins\n" {
        t.Errorf("nach halber Zeile: %q", got)
    }
    appendTo(t, path, "ei\n")
    waitFor(t, out, "eins\nzwei\n")

    // copytruncate: Datei wird kleiner
    if err := os.WriteFile(path, []byte("neu\n"), 0o644); err != nil {
        t.Fatal(err)
    }
    waitFor(t, out, "zwei\nneu\n")

    // Rotation: alte Datei umbenennen, neue anlegen
    appendTo(t, path, "letzte alte\n")
    if err := os.Rename(path, path+".1"); err != nil {
        t.Fatal(err)
    }
    appendTo(t, path, "rotiert\n")
    waitFor(t, out, "neu\nletzte alte\nrotiert\n")

    cancel()
    if err := <-done; err != nil {
        t.Errorf("Follow nach cancel: %v", err)
    }
}
EOF

syncBuf ist nötig, weil Follow in einer eigenen Goroutine schreibt, während der Test liest – ein nackter bytes.Buffer wäre ein Data Race, und ziel läuft mit -race.

Musterlösung

cat > internal/tail/tail.go <<'EOF'
// Package tail folgt einer Logdatei wie tail -F – per Polling, ohne fsnotify.
package tail

import (
    "bufio"
    "bytes"
    "context"
    "io"
    "os"
    "time"
)

// Last liefert die letzten n Zeilen von path und das Byte-Offset danach.
func Last(path string, n int) ([]string, int64, error) {
    f, err := os.Open(path)
    if err != nil {
        return nil, 0, err
    }
    defer f.Close()
    info, err := f.Stat()
    if err != nil {
        return nil, 0, err
    }
    var ring []string // höchstens n Zeilen im Speicher, auch bei GB-Logs
    sc := bufio.NewScanner(io.LimitReader(f, info.Size()))
    for sc.Scan() {
        ring = append(ring, sc.Text())
        if len(ring) > n {
            ring = ring[1:]
        }
    }
    return ring, info.Size(), sc.Err()
}

// follower merkt sich offene Datei, Position und eine angefangene Zeile.
type follower struct {
    path    string
    f       *os.File
    info    os.FileInfo
    off     int64
    partial []byte
    out     io.Writer
}

// Follow schreibt ab Offset off jede neue, vollständige Zeile nach out,
// bis ctx endet. Erkennt Truncate (Datei kleiner) und Rotation (neue Datei).
func Follow(ctx context.Context, path string, off int64, every time.Duration,
    out io.Writer) error {
    fw := &follower{path: path, off: off, out: out}
    if err := fw.open(); err != nil {
        return err
    }
    defer func() { fw.f.Close() }()
    t := time.NewTicker(every)
    defer t.Stop()
    for {
        if err := fw.read(); err != nil {
            return err
        }
        select {
        case <-ctx.Done():
            return nil // Strg+C ist kein Fehler
        case <-t.C:
        }
        cur, err := os.Stat(path)
        switch {
        case err != nil: // gerade rotiert, neue Datei fehlt noch
        case !os.SameFile(fw.info, cur): // Rotation: Rest lesen, neu öffnen
            if err := fw.read(); err != nil {
                return err
            }
            fw.f.Close()
            fw.off, fw.partial = 0, nil
            if err := fw.open(); err != nil {
                return err
            }
        case cur.Size() < fw.off: // copytruncate: von vorn
            fw.off, fw.partial = 0, nil
        }
    }
}

func (fw *follower) open() error {
    f, err := os.Open(fw.path)
    if err != nil {
        return err
    }
    info, err := f.Stat()
    if err != nil {
        f.Close()
        return err
    }
    fw.f, fw.info = f, info
    return nil
}

// read liest alles ab fw.off und gibt nur Zeilen mit \n aus.
func (fw *follower) read() error {
    data, err := io.ReadAll(io.NewSectionReader(fw.f, fw.off, 1<<62))
    if err != nil {
        return err
    }
    fw.off += int64(len(data))
    data = append(fw.partial, data...)
    end := bytes.LastIndexByte(data, '\n') + 1
    if _, err := fw.out.Write(data[:end]); err != nil {
        return err
    }
    fw.partial = append([]byte(nil), data[end:]...)
    return nil
}
EOF
cat > cmd/logtail/main.go <<'EOF'
// logtail zeigt die letzten Zeilen einer Datei und folgt ihr wie tail -F:
// logtail [-n 10] [-i 250ms] DATEI
// Tag 15 aus "Go zum Anfassen".
package main

import (
    "context"
    "flag"
    "fmt"
    "io"
    "os"
    "os/signal"
    "syscall"
    "time"

    "example.com/logtail/internal/tail"
)

func main() {
    ctx, stop := signal.NotifyContext(context.Background(),
        os.Interrupt, syscall.SIGTERM)
    defer stop()
    os.Exit(run(ctx, os.Args[1:], os.Stdout, os.Stderr))
}

func run(ctx context.Context, args []string, stdout, stderr io.Writer) int {
    fl := flag.NewFlagSet("logtail", flag.ContinueOnError)
    fl.SetOutput(stderr)
    n := fl.Int("n", 10, "so viele Zeilen zuerst zeigen")
    every := fl.Duration("i", 250*time.Millisecond, "Prüfintervall")
    if err := fl.Parse(args); err != nil {
        return 2
    }
    if fl.NArg() != 1 || *n < 0 || *every <= 0 {
        fmt.Fprintln(stderr, "Aufruf: logtail [-n 10] [-i 250ms] DATEI")
        return 2
    }
    path := fl.Arg(0)
    lines, off, err := tail.Last(path, *n)
    if err != nil {
        fmt.Fprintln(stderr, "logtail:", err)
        return 1
    }
    for _, l := range lines {
        fmt.Fprintln(stdout, l)
    }
    if err := tail.Follow(ctx, path, off, *every, stdout); err != nil {
        fmt.Fprintln(stderr, "logtail:", err)
        return 1
    }
    return 0
}
EOF
ziel
go test -race -count=30 ./internal/tail

Erwartet (gekürzt):

0 issues.
Zeit: 28 min
ok      example.com/logtail/internal/tail   4.160s

Warum? os.SameFile vergleicht Gerät und Inode – so erkennt Follow eine neue Datei unter altem Namen, ohne den Inhalt anzusehen. Der alte Dateideskriptor bleibt nach mv gültig; deshalb lässt sich der Rest noch lesen. -count=30 wiederholt den zeitabhängigen Test – ein flackernder Test fällt so vor dem Kollegen auf.

go build -o bin/logtail ./cmd/logtail
for i in 1 2 3 4 5; do echo "boot $i" >> app.log; done
./bin/logtail -n 2 app.log > out.txt & pid=$!
sleep 0.5; echo "request 1" >> app.log; sleep 0.5
echo "nach truncate" > app.log; sleep 0.5
mv app.log app.log.1; echo "neue Datei" > app.log; sleep 0.5
kill -INT $pid; wait $pid; echo "exit=$?"
cat out.txt

Erwartet:

exit=0
boot 4
boot 5
request 1
nach truncate
neue Datei

Fortschritt speichern? Kostenlos registrieren

Challenge 7: llm-commit – Commit-Message vom lokalen Modell

Zeitlimit: 30 min · Punkte: 20 · Bausteine: net/http, JSON, os/exec, Validieren und Reparieren (Tag 5, 7, 12)

Spezifikation

  • commit.Client{BaseURL, Model, Key, HTTP} schickt POST {BaseURL}/chat/completions (OpenAI-kompatibel, wie Tag 12) mit System-Prompt und Diff; Authorization: Bearer … nur, wenn Key gesetzt ist.
  • commit.Clean(s) entfernt Markdown-Zäune, umschließende Anführungszeichen, Leerraum und doppelte Leerzeilen und setzt genau eine Leerzeile zwischen Betreff und Body.
  • commit.Valid(msg) verlangt einen Betreff nach Conventional Commits (feat, fix, docs, refactor, test, chore, build, ci, perf, style, optional (scope) und !) mit höchstens 72 Zeichen.
  • Client.Message(ctx, diff) bereinigt und prüft jede Antwort. Ist sie ungültig, bekommt das Modell den Fehler als neue Nachricht – höchstens attempts = 3 Anfragen insgesamt. commit.Truncate(diff, limit) kürzt an einer Zeilengrenze.
  • CLI: llm-commit [-stdin] [-max 12000] liest git diff --cached (oder stdin), nutzt LLM_BASE_URL, LLM_MODEL, LLM_API_KEY wie Tag 12, gibt nur die Message auf stdout aus. Exit 1 bei leerem Diff oder LLM-Fehler, 2 = Aufruf.

Tests

start llm-commit commit
cat > internal/commit/commit_test.go <<'EOF'
package commit

import (
    "context"
    "encoding/json"
    "fmt"
    "net/http"
    "net/http/httptest"
    "strings"
    "sync/atomic"
    "testing"
)

func TestClean(t *testing.T) {
    tests := []struct{ in, want string }{
        {"feat: neu", "feat: neu"},
        {"```\nfix(api): Timeout setzen\n```", "fix(api): Timeout setzen"},
        {"\"docs: README\"", "docs: README"},
        {"feat: x\nBody direkt", "feat: x\n\nBody direkt"},
        {"  chore: y  \n\n\n\nmehr  ", "chore: y\n\nmehr"},
    }
    for _, tt := range tests {
        if got := Clean(tt.in); got != tt.want {
            t.Errorf("Clean(%q) = %q, will %q", tt.in, got, tt.want)
        }
    }
}

func TestValid(t *testing.T) {
    ok := []string{"feat: neu", "fix(api)!: Bruch", "ci(go): Lint in CI"}
    bad := []string{"Added stuff", "feat:ohne Leerzeichen", "feat: " +
        strings.Repeat("x", 70), "", "feature: falscher Typ"}
    for _, s := range ok {
        if err := Valid(s); err != nil {
            t.Errorf("Valid(%q) = %v", s, err)
        }
    }
    for _, s := range bad {
        if Valid(s) == nil {
            t.Errorf("Valid(%q) = nil, will Fehler", s)
        }
    }
}

func TestTruncate(t *testing.T) {
    diff := strings.Repeat("+zeile\n", 100) // 700 Bytes
    got, cut := Truncate(diff, 50)
    if !cut || len(got) > 50 || !strings.HasSuffix(got, "+zeile\n") {
        t.Errorf("Truncate = %q, %v", got, cut)
    }
    if got, cut := Truncate("kurz\n", 50); cut || got != "kurz\n" {
        t.Errorf("kurzer Diff verändert: %q, %v", got, cut)
    }
}

// fakeLLM antwortet nacheinander mit answers und prüft jede Anfrage.
func fakeLLM(t *testing.T, answers ...string) (*Client, *atomic.Int32) {
    t.Helper()
    var calls atomic.Int32
    srv := httptest.NewServer(http.HandlerFunc(
        func(w http.ResponseWriter, r *http.Request) {
            n := calls.Add(1)
            if r.URL.Path != "/chat/completions" ||
                r.Header.Get("Authorization") != "Bearer sk-lab-1234" {
                t.Errorf("Anfrage: %s %q", r.URL.Path, r.Header.Get("Authorization"))
            }
            var req request
            if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
                t.Error(err)
            }
            last := req.Messages[len(req.Messages)-1].Content
            if req.Model != "lab-model" || (n == 1 && !strings.Contains(last, "+x")) {
                t.Errorf("Request %d: model=%q, zuletzt %q", n, req.Model, last)
            }
            a, _ := json.Marshal(answers[min(int(n), len(answers))-1])
            fmt.Fprintf(w, `{"choices":[{"message":{"role":"assistant",`+
                `"content":%s}}]}`, a)
        }))
    t.Cleanup(srv.Close)
    return &Client{BaseURL: srv.URL, Model: "lab-model", Key: "sk-lab-1234",
        HTTP: srv.Client()}, &calls
}

func TestMessage(t *testing.T) {
    c, calls := fakeLLM(t, "```\nfeat(api): /healthz ergänzen\n```")
    msg, err := c.Message(context.Background(), "+x\n")
    if err != nil || msg != "feat(api): /healthz ergänzen" || calls.Load() != 1 {
        t.Errorf("Message = %q, %v (%d Aufrufe)", msg, err, calls.Load())
    }
}

func TestMessageReparatur(t *testing.T) {
    c, calls := fakeLLM(t, "Added a health endpoint", "feat: Health-Endpunkt")
    msg, err := c.Message(context.Background(), "+x\n")
    if err != nil || msg != "feat: Health-Endpunkt" || calls.Load() != 2 {
        t.Errorf("Message = %q, %v (%d Aufrufe)", msg, err, calls.Load())
    }
}

func TestMessageGibtAuf(t *testing.T) {
    c, calls := fakeLLM(t, "Quatsch")
    if _, err := c.Message(context.Background(), "+x\n"); err == nil ||
        calls.Load() != attempts {
        t.Errorf("err = %v nach %d Aufrufen, will Fehler nach %d", err,
            calls.Load(), attempts)
    }
}
EOF

fakeLLM ist ein httptest-Server, der nacheinander vorgegebene Antworten liefert und jede Anfrage prüft – das echte Modell brauchst du erst ganz am Ende.

Musterlösung

cat > internal/commit/commit.go <<'EOF'
// Package commit lässt ein LLM aus einem git diff eine Commit-Message schreiben.
package commit

import (
    "bytes"
    "context"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "regexp"
    "strings"
)

const system = `Du schreibst Commit-Messages im Format Conventional Commits.
Erste Zeile: typ(scope): beschreibung – höchstens 72 Zeichen, Imperativ.
Typen: feat, fix, docs, refactor, test, chore, build, ci, perf, style.
Danach optional eine Leerzeile und 1-3 Zeilen Begründung.
Antworte nur mit der Commit-Message, ohne Erklärungen und ohne Markdown.`

var subjectRe = regexp.MustCompile(
    `^(feat|fix|docs|refactor|test|chore|build|ci|perf|style)(\([\w./-]+\))?!?: \S`)

// Valid prüft die erste Zeile gegen Conventional Commits.
func Valid(msg string) error {
    subject, _, _ := strings.Cut(msg, "\n")
    if !subjectRe.MatchString(subject) {
        return fmt.Errorf("betreff %q ist kein Conventional Commit", subject)
    }
    if n := len([]rune(subject)); n > 72 {
        return fmt.Errorf("betreff hat %d Zeichen, erlaubt sind 72", n)
    }
    return nil
}

// Clean entfernt Markdown-Zäune, Anführungszeichen und überflüssige Leerzeilen
// und setzt genau eine Leerzeile zwischen Betreff und Body.
func Clean(s string) string {
    var lines []string
    for l := range strings.Lines(strings.Trim(strings.TrimSpace(s), `"`)) {
        l = strings.TrimSpace(l)
        if strings.HasPrefix(l, "```") {
            continue
        }
        if l == "" && (len(lines) == 0 || lines[len(lines)-1] == "") {
            continue // keine doppelten Leerzeilen
        }
        lines = append(lines, l)
    }
    if len(lines) > 1 && lines[1] != "" {
        lines = append(lines[:1], append([]string{""}, lines[1:]...)...)
    }
    return strings.TrimSpace(strings.Join(lines, "\n"))
}

// Truncate kürzt diff an einer Zeilengrenze auf höchstens limit Bytes.
func Truncate(diff string, limit int) (string, bool) {
    if len(diff) <= limit {
        return diff, false
    }
    cut := diff[:limit]
    if i := strings.LastIndexByte(cut, '\n'); i >= 0 {
        cut = cut[:i+1]
    }
    return cut, true
}

type message struct {
    Role    string `json:"role"`
    Content string `json:"content"`
}

type request struct {
    Model       string    `json:"model"`
    Messages    []message `json:"messages"`
    Temperature float64   `json:"temperature"`
}

// Client spricht eine OpenAI-kompatible Chat-API an (Ollama, vLLM, Mistral).
type Client struct {
    BaseURL, Model, Key string
    HTTP                *http.Client
}

// attempts: so oft darf das Modell eine ungültige Antwort reparieren.
const attempts = 3

// Message erzeugt eine Commit-Message. Ist eine Antwort ungültig, bekommt
// das Modell den Fehler als Rückmeldung und einen neuen Versuch.
func (c *Client) Message(ctx context.Context, diff string) (string, error) {
    msgs := []message{
        {Role: "system", Content: system},
        {Role: "user", Content: "Schreibe die Commit-Message für:\n\n" + diff},
    }
    var err error
    for range attempts {
        var answer string
        answer, err = c.chat(ctx, msgs)
        if err != nil {
            return "", err
        }
        msg := Clean(answer)
        if err = Valid(msg); err == nil {
            return msg, nil
        }
        msgs = append(msgs, message{Role: "assistant", Content: answer},
            message{Role: "user", Content: "Ungültig: " + err.Error() +
                ". Antworte nur mit der korrigierten Commit-Message."})
    }
    return "", err
}

func (c *Client) chat(ctx context.Context, msgs []message) (string, error) {
    body, err := json.Marshal(request{Model: c.Model, Messages: msgs,
        Temperature: 0.2})
    if err != nil {
        return "", err
    }
    req, err := http.NewRequestWithContext(ctx, http.MethodPost,
        c.BaseURL+"/chat/completions", bytes.NewReader(body))
    if err != nil {
        return "", err
    }
    req.Header.Set("Content-Type", "application/json")
    if c.Key != "" {
        req.Header.Set("Authorization", "Bearer "+c.Key)
    }
    resp, err := c.HTTP.Do(req)
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()
    if resp.StatusCode != http.StatusOK {
        msg, _ := io.ReadAll(io.LimitReader(resp.Body, 512))
        return "", fmt.Errorf("LLM: %s: %s", resp.Status, bytes.TrimSpace(msg))
    }
    var out struct {
        Choices []struct {
            Message message `json:"message"`
        } `json:"choices"`
    }
    if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
        return "", err
    }
    if len(out.Choices) == 0 {
        return "", fmt.Errorf("LLM: Antwort ohne choices")
    }
    return out.Choices[0].Message.Content, nil
}
EOF
cat > cmd/llm-commit/main.go <<'EOF'
// llm-commit schreibt eine Commit-Message aus dem gestagten Diff per LLM:
// git add -p && llm-commit | git commit -F -
// Tag 15 aus "Go zum Anfassen".
package main

import (
    "cmp"
    "context"
    "flag"
    "fmt"
    "io"
    "net/http"
    "os"
    "os/exec"
    "os/signal"
    "strings"
    "time"

    "example.com/llm-commit/internal/commit"
)

func main() {
    ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
    defer stop()
    os.Exit(run(ctx, os.Args[1:], os.Getenv, os.Stdin, os.Stdout, os.Stderr))
}

func run(ctx context.Context, args []string, getenv func(string) string,
    stdin io.Reader, stdout, stderr io.Writer) int {
    fl := flag.NewFlagSet("llm-commit", flag.ContinueOnError)
    fl.SetOutput(stderr)
    fromStdin := fl.Bool("stdin", false, "Diff von stdin statt git diff --cached")
    limit := fl.Int("max", 12000, "höchstens so viele Bytes Diff ans Modell")
    timeout := fl.Duration("timeout", 2*time.Minute, "Gesamtbudget")
    if err := fl.Parse(args); err != nil || fl.NArg() != 0 {
        fmt.Fprintln(stderr, "Aufruf: llm-commit [-stdin] [-max 12000]")
        return 2
    }
    ctx, cancel := context.WithTimeout(ctx, *timeout)
    defer cancel()

    var diff []byte
    var err error
    if *fromStdin {
        diff, err = io.ReadAll(stdin)
    } else {
        diff, err = exec.CommandContext(ctx, "git", "diff", "--cached",
            "--no-color").Output()
    }
    if err != nil {
        fmt.Fprintln(stderr, "llm-commit: diff lesen:", err)
        return 1
    }
    if strings.TrimSpace(string(diff)) == "" {
        fmt.Fprintln(stderr, "llm-commit: nichts gestaged (git add vergessen?)")
        return 1
    }
    d, cut := commit.Truncate(string(diff), *limit)
    if cut {
        fmt.Fprintf(stderr, "llm-commit: Diff auf %d Bytes gekürzt\n", len(d))
    }

    c := &commit.Client{
        BaseURL: cmp.Or(getenv("LLM_BASE_URL"), "http://127.0.0.1:11434/v1"),
        Model:   cmp.Or(getenv("LLM_MODEL"), "ministral-3:3b"),
        Key:     getenv("LLM_API_KEY"),
        HTTP:    &http.Client{},
    }
    msg, err := c.Message(ctx, d)
    if err != nil {
        fmt.Fprintln(stderr, "llm-commit:", err)
        return 1
    }
    fmt.Fprintln(stdout, msg)
    return 0
}
EOF
ziel

Warum? Ein 3B-Modell hält Formatregeln nicht immer ein. Statt auf Glück zu hoffen, prüft Code die Antwort, und der Fehlertext geht als Rückmeldung zurück an das Modell – dasselbe Muster wie bei der JSON-Ausgabe an Tag 12. strings.Lines (Go 1.24) liefert die Zeilen als Iterator, inklusive \n.

Jetzt gegen Ollama – in einem Wegwerf-Repo, damit dein echtes Git unberührt bleibt:

go build -o bin/llm-commit ./cmd/llm-commit
cd "$(mktemp -d)" && git init -q
cp ~/go-lab/tag15-portwait/cmd/portwait/main.go .
git add . && git commit -qm "chore: start"
perl -pi -e 's/30\*time.Second/60*time.Second/' main.go && git add main.go
~/go-lab/tag15-llm-commit/bin/llm-commit
~/go-lab/tag15-llm-commit/bin/llm-commit | git commit -q -F - && git log --oneline
~/go-lab/tag15-llm-commit/bin/llm-commit; echo "exit=$?"
cd ~/go-lab/tag15-llm-commit

Erwartet (Formulierung variiert von Lauf zu Lauf):

fix(portwait): erhöhe timeout auf 60 Sekunden für bessere Stabilität
9732fae fix(main): timeout von 30s auf 60s erhöhen
f998523 chore: start
llm-commit: nichts gestaged (git add vergessen?)
exit=1

Sicherheit: Ein Diff kann Secrets enthalten. Schick ihn nur an ein lokales Modell oder an eine API, die dein Arbeitgeber freigegeben hat – und lass vorher einen Scanner wie secretscan aus Anhang B darüberlaufen.

Fortschritt speichern? Kostenlos registrieren

Bewertung

Volle Punkte, wenn ziel innerhalb des Zeitlimits grün meldet; halbe Punkte bis zur doppelten Zeit; danach keine.

Challenge Zeitlimit Punkte erreicht
1 portwait 20 min 10
2 dupfind 30 min 15
3 jsonq 30 min 15
4 envdiff 20 min 10
5 certdays 25 min 15
6 logtail 30 min 15
7 llm-commit 30 min 20
Summe 185 min 100

Ab 70 Punkten bist du wettkampfreif für die Abschlussprüfung (Anhang B). Notiere bei jeder verpassten Zeit in einem Satz, woran es hing – meist ist es dasselbe Thema, und dann weißt du, welchen Tag du wiederholst.

Kontrollpunkt

#!/usr/bin/env bash
check() { if eval "$2" >/dev/null 2>&1; then echo "✔ $1"; else echo "✘ $1"; fi; }
for d in ~/go-lab/tag15-*/; do
  t=$(basename "$d"); t=${t#tag15-}
  check "$t: fmt, vet, Tests mit -race, Lint" "cd $d && test -z \"\$(gofmt -l .)\" \
    && go vet ./... && go test -race -count=1 ./... && ~/go-lab/bin/lint run ./..."
done
b=~/go-lab/tag15
check "portwait: Exit 1 bei Timeout" \
  "$b-portwait/bin/portwait -timeout 300ms 127.0.0.1:1; test \$? -eq 1"
check "jsonq wie jq" "diff <($b-jsonq/bin/jsonq '.[0]' $b-jsonq/releases.json) \
  <(jq -cS '.[0]' $b-jsonq/releases.json)"
check "envdiff: Exit 0 bei gleichen Dateien" \
  "$b-envdiff/bin/envdiff $b-envdiff/prod.env $b-envdiff/prod.env"
check "certdays: lab.pem unter 30 Tagen" \
  "$b-certdays/bin/certdays $b-certdays/lab.pem; test \$? -eq 1"
check "llm-commit: Exit 2 bei falschem Aufruf" \
  "$b-llm-commit/bin/llm-commit extra; test \$? -eq 2"

Erwartet:

✔ certdays: fmt, vet, Tests mit -race, Lint
✔ dupfind: fmt, vet, Tests mit -race, Lint
✔ envdiff: fmt, vet, Tests mit -race, Lint
✔ jsonq: fmt, vet, Tests mit -race, Lint
✔ llm-commit: fmt, vet, Tests mit -race, Lint
✔ logtail: fmt, vet, Tests mit -race, Lint
✔ portwait: fmt, vet, Tests mit -race, Lint
✔ portwait: Exit 1 bei Timeout
✔ jsonq wie jq
✔ envdiff: Exit 0 bei gleichen Dateien
✔ certdays: lab.pem unter 30 Tagen
✔ llm-commit: Exit 2 bei falschem Aufruf

Challenge

Kür ohne Zeitlimit: Gib mit zwei deiner neuen Tools nur die Pfade der Duplikat-Gruppe aus, die am meisten Platz verschwendet – ohne jq.

Hinweis: dupfind sortiert bereits nach Verschwendung, und jsonq liest stdin.

Lösung

cd ~/go-lab/tag15-dupfind
./bin/dupfind -json demo | ../tag15-jsonq/bin/jsonq -r '.[0].Paths[]'

Erwartet:

demo/sub/w2
demo/w1

Kleine Tools, die JSON sprechen und saubere Exit-Codes haben, setzen sich in Pipes von selbst zusammen – das ist die Unix-Idee, und Go liefert sie als statische Binaries.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Spezifikation plus Tests vor dem Code ist auch im Team der beste Auftrag – für Kollegen wie für KI-Assistenten: Die Tests sind der Vertrag, ziel die Abnahme in CI.
  • portwait ersetzt Shell-Schleifen in Entrypoints; in Kubernetes gehören Abhängigkeiten aber in Readiness-Probes und Retries der App, nicht in Init-Container, die ewig warten.
  • certdays ist ein guter Ad-hoc-Check; dauerhaft überwacht probe_ssl_earliest_cert_expiry vom Prometheus-Blackbox-Exporter, und cert-manager erneuert, bevor jemand warnen muss.
  • logtail verliert bei copytruncate Zeilen, die zwischen Kopie und Truncate geschrieben werden; in Containern gehören Logs nach stdout, das Sammeln übernehmen Fluent Bit oder Vector.
  • LLM-Werkzeuge im Firmen-Repo: nur freigegebene Modelle, Diffs vorher auf Secrets prüfen, Ergebnis immer vom Menschen gegenlesen lassen – das Modell schlägt vor, du committest.