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 vetund 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
zielgrün meldet. - Die Tests sind der Schiedsrichter. Ändere sie nicht – außer bei eigenen Tippfehlern.
- Erst das Paket unter
internal/gegen die Tests, danncmd/<tool>/main.gonach dem bekannten Muster: dünnesmain,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 zielErwartet:
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 Fehlversuchn(ab 0):initial·2^n, höchstenslimit– ohne Überlauf, auch bein = 100.wait.Port(ctx, addr, wait.Options)versucht perOptions.Dial(Default:net.Dialer.DialContext) eine TCP-Verbindung, bis es klappt, und liefert die Zahl der Versuche. Defaults:Initial100 ms,Max2 s.- Nach jedem Fehlversuch ruft
Port– falls gesetzt –Options.OnRetry(versuch, err, pause). - Endet
ctx, kehrtPortsofort zurück; der Fehler enthältcontext.DeadlineExceededbzw.context.Canceled(prüfbar miterrors.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/waitErwartet (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
zielErwartet (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)durchsuchtrootrekursiv 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,
Pathssortiert. Gruppen sortiert nachWasted()(Größe × Anzahl Kopien) absteigend, dann nach erstem Pfad. - Hashen mit
workersGoroutines; gleiches Ergebnis bei 1 und 8 Workern. Abgebrochenerctxliefertcontext.Canceled, fehlender Ordner einen Fehler mitos.ErrNotExist. - CLI:
dupfind [-w N] [-json] ORDNER, Default für-wist 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)
}
}
EOFMusterlö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
zielWarum? 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 ausencoding/jsonaus (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:
.xaufnulloder einen fehlenden Schlüssel liefertnull, ebenso ein Index außerhalb des Arrays. - Fehler: Ausdruck ohne führenden Punkt, leerer Schlüssel, kaputter
Index →
ErrSyntax;.xauf 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-rStrings ohne Anführungszeichen. Zahlen bleiben exakt (98000000, nicht9.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
})
}
EOFMusterlö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 -2Erwartet (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)liestKEY=VALUE-Zeilen: Leerzeilen und#-Kommentare überspringen,exportvorn 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}mitAdded(+),Removed(-),Changed(~), sortiert nach Schlüssel.envfile.Mask(v)verrät nur die Länge:<6 Zeichen>, leer:"".- CLI:
envdiff [-show] ALT NEUmaskiert Werte, außer mit-show. Exit wiediff: 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)
}
}
}
EOFMusterlö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
zielWarum? 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 alleCERTIFICATE-Blöcke (Bundle, Chain) und überspringt andere Blöcke wie Keys. Kein Zertifikat: Fehler mitErrNoCert.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.InfoenthältSource,Subject(CN=…),NotAfter,Days.- CLI:
certdays [-warn 30] [-timeout 5s] ZIEL...; ZIEL ist eine vorhandene Datei oderhost:port. Tabelle mitTAGE ABLAUF SUBJECT QUELLE,✘unter-warn. Exit 1, wenn eins unter-warnliegt 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)
}
}
EOFDer 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
zielWarum? 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:
InsecureSkipVerifyist 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 letztennZeilen und das Byte-Offset dahinter – mit konstantem Speicher, auch bei großen Dateien.tail.Follow(ctx, path, off, every, out)prüft alleeverydie Datei und schreibt jede neue, vollständige Zeile (mit\n) nachout. 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, gibtFollownilzurü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)
}
}
EOFsyncBuf 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/tailErwartet (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.txtErwartet:
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}schicktPOST {BaseURL}/chat/completions(OpenAI-kompatibel, wie Tag 12) mit System-Prompt und Diff;Authorization: Bearer …nur, wennKeygesetzt 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öchstensattempts = 3Anfragen insgesamt.commit.Truncate(diff, limit)kürzt an einer Zeilengrenze.- CLI:
llm-commit [-stdin] [-max 12000]liestgit diff --cached(oder stdin), nutztLLM_BASE_URL,LLM_MODEL,LLM_API_KEYwie 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)
}
}
EOFfakeLLM 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
zielWarum? 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-commitErwartet (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
secretscanaus 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,
zieldie Abnahme in CI. portwaitersetzt 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.certdaysist ein guter Ad-hoc-Check; dauerhaft überwachtprobe_ssl_earliest_cert_expiryvom Prometheus-Blackbox-Exporter, und cert-manager erneuert, bevor jemand warnen muss.logtailverliert beicopytruncateZeilen, 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.