Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 4: Funktionen und eine Bibliothek

Ziel: Funktionen schreiben, Ergebnisse über Exit-Code und Ausgabe zurückgeben, Variablen mit local schützen, eine gemeinsame Bibliothek lib.sh für den Werkzeugkasten bauen und Skripte mit bash -x untersuchen. · Dauer: ca. 75 min · Voraussetzung: Tag 3

Briefing

  • Eine Funktion ist ein Mini-Skript in deinem Skript: eigene Argumente ($1, $@), eigener Exit-Code (return). Ergebnisse gibt sie über die Ausgabe zurück, die der Aufrufer mit $(…) einfängt.
  • Variablen in Funktionen sind ohne local global – ein häufiger, schwer zu findender Fehler.
  • Was mehrere Skripte brauchen, kommt in eine Bibliothek, die jedes Skript mit source lädt: Logging, Abbruch mit Meldung, Prüfung benötigter Programme.
  • bash -x zeigt jede Zeile, bevor sie läuft – das wichtigste Werkzeug zur Fehlersuche.
 bin/notes-ping ─┐
 bin/notes-add  ─┼─ source ─► lib/lib.sh: log · info · warn · die · need · notes_url
 bin/notes-last ─┘

Drill 1: Funktionen

source ~/sh-lab/setup/env.sh
mkdir -p ~/sh-lab/tag04 && cd ~/sh-lab/tag04
cat > funktionen <<'EOF'
#!/usr/bin/env bash
set -euo pipefail

ist_zahl() {
  [[ $1 =~ ^[0-9]+$ ]]
}

verdoppeln() {
  echo $(($1 * 2))
}

for x in 21 abc; do
  if ist_zahl "$x"; then
    echo "$x verdoppelt: $(verdoppeln "$x")"
  else
    echo "$x ist keine Zahl"
  fi
done
EOF
bash funktionen

Erwartet:

21 verdoppelt: 42
abc ist keine Zahl
  • ist_zahl gibt nichts aus. Ihr Ergebnis ist der Exit-Code des letzten Befehls – genau wie bei einem Skript. Deshalb funktioniert sie direkt hinter if.
  • verdoppeln liefert ihr Ergebnis als Ausgabe. return 42 ginge nicht: Exit-Codes sind nur 0 bis 255 und bedeuten Erfolg oder Fehler, keine Daten.

Fortschritt speichern? Kostenlos registrieren

Drill 2: local

cat > global <<'EOF'
#!/usr/bin/env bash
set -euo pipefail
zaehle_dateien() {
  n=$(find "$1" -maxdepth 1 -type f | wc -l)
  echo "$n"
}
n="Notiz Nr. 7"
echo "vorher:  $n"
echo "Dateien: $(zaehle_dateien /etc/apt)"
zaehle_dateien /etc/apt >/dev/null
echo "nachher: $n"
EOF
bash global

Erwartet:

vorher:  Notiz Nr. 7
Dateien: 1
nachher: 1

Der erste Aufruf in $(…) läuft in einer Unter-Shell und kann n nicht ändern. Der zweite läuft direkt – und überschreibt n. Mit local passiert das nicht:

sed -i 's/^  n=\$(find/  local n\n  n=$(find/' global
sed -n '3,6p' global
bash global

Erwartet:

zaehle_dateien() {
  local n
  n=$(find "$1" -maxdepth 1 -type f | wc -l)
  echo "$n"
vorher:  Notiz Nr. 7
Dateien: 1
nachher: Notiz Nr. 7

local n steht in einer eigenen Zeile: local n=$(…) würde den Exit-Code von find verschlucken, weil local selbst immer Erfolg meldet (ShellCheck SC2155).

Fortschritt speichern? Kostenlos registrieren

Drill 3: lib.sh

cat > ~/sh-lab/werkzeug/lib/lib.sh <<'EOF'
# lib.sh – gemeinsame Funktionen für den Werkzeugkasten. Laden mit: source …/lib.sh
# shellcheck shell=bash
[[ -n "${_LIB_SH:-}" ]] && return 0
_LIB_SH=1

PROG="${0##*/}"

log() { printf '%s %s: %s\n' "$(date +%H:%M:%S)" "$PROG" "$*" >&2; }
info() { log "INFO $*"; }
warn() { log "WARN $*"; }
die() {
  log "FEHLER $1"
  exit "${2:-1}"
}

# need prog…  – bricht mit Exit-Code 3 ab, wenn ein Programm fehlt
need() {
  local p
  for p in "$@"; do
    command -v "$p" >/dev/null || die "Programm fehlt: $p" 3
  done
}

notes_url() { printf '%s\n' "${NOTES_URL:-http://127.0.0.1:8080}"; }
EOF
shellcheck ~/sh-lab/werkzeug/lib/lib.sh && echo sauber
printf 'source-path=SCRIPTDIR\n' > ~/sh-lab/werkzeug/.shellcheckrc

Erwartet:

sauber
  • Die Bibliothek hat keinen Shebang und kein set -euo pipefail – sie läuft im Skript, das sie lädt. # shellcheck shell=bash sagt ShellCheck, welche Sprache gilt.
  • Der Guard _LIB_SH verhindert, dass sie doppelt geladen wird.
  • Meldungen gehen auf stderr. So bleibt stdout frei für das eigentliche Ergebnis.

Wie findet ein Skript die Bibliothek, egal von wo es aufgerufen wird? Über seinen eigenen Pfad:

cat > ~/sh-lab/werkzeug/bin/notes-ping <<'EOF'
#!/usr/bin/env bash
# notes-ping – prüft, ob notes antwortet. Exit-Code 0 = ok
set -euo pipefail
source "$(dirname "$(readlink -f "${BASH_SOURCE[0]}")")/../lib/lib.sh"
need curl
url="$(notes_url)"
curl -fsS --max-time 3 "$url/healthz" >/dev/null 2>&1 || die "nicht erreichbar: $url"
echo "notes ok"
EOF
shellcheck -x ~/sh-lab/werkzeug/bin/notes-ping && echo sauber
cd / && notes-ping
NOTES_URL=http://127.0.0.1:9 notes-ping; echo "Exit: $?"

Erwartet:

sauber
notes ok
12:20:14 notes-ping: FEHLER nicht erreichbar: http://127.0.0.1:9
Exit: 1

readlink -f löst Links auf, BASH_SOURCE[0] ist der Pfad der laufenden Datei. shellcheck -x folgt dem source und prüft die Bibliothek mit. Den berechneten Pfad kann ShellCheck nicht ausrechnen; source-path=SCRIPTDIR in der .shellcheckrc sagt ihm, dass ../lib/lib.sh vom Ordner des Skripts aus gemeint ist. ShellCheck sucht die Datei in jedem übergeordneten Ordner des geprüften Skripts.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Fehlersuche mit bash -x

NOTES_URL=http://127.0.0.1:9 bash -x ~/sh-lab/werkzeug/bin/notes-ping 2>&1 \
  | grep -v '^++* date' | head -12

Erwartet (gekürzt):

+ set -euo pipefail
+++ readlink -f /home/ubuntu/sh-lab/werkzeug/bin/notes-ping
++ dirname /home/ubuntu/sh-lab/werkzeug/bin/notes-ping
+ source /home/ubuntu/sh-lab/werkzeug/bin/../lib/lib.sh
++ [[ -n '' ]]
++ _LIB_SH=1
++ PROG=notes-ping
+ need curl
+ local p
+ for p in "$@"
+ command -v curl
++ notes_url

Jede Zeile beginnt mit +, eine Ebene tiefer (Unter-Shell, source) mit ++. Du siehst die Werte nach dem Ersetzen – genau das, was ausgeführt wird. Im Skript schaltest du die Ablaufverfolgung mit set -x an und mit set +x wieder aus.

Fortschritt speichern? Kostenlos registrieren

Drill 5: notes-add mit lib.sh

cat > ~/sh-lab/werkzeug/bin/notes-add <<'EOF'
#!/usr/bin/env bash
# notes-add – legt eine Notiz an: notes-add Text der Notiz
set -euo pipefail
source "$(dirname "$(readlink -f "${BASH_SOURCE[0]}")")/../lib/lib.sh"
need curl
(($# > 0)) || die "Aufruf: $PROG Text der Notiz" 2
key="${NOTES_API_KEY:?fehlt – source ~/sh-lab/setup/env.sh}"
text="$*"
curl -fsS -X POST -H "X-API-Key: $key" -H 'Content-Type: application/json' \
  -d "{\"text\":\"$text\"}" "$(notes_url)/notes"
echo
EOF
shellcheck -x ~/sh-lab/werkzeug/bin/notes-add && echo sauber
notes-add; echo "Exit: $?"
notes-add mit Bibliothek | grep -o '"text":"[^"]*"'

Erwartet:

sauber
12:21:02 notes-add: FEHLER Aufruf: notes-add Text der Notiz
Exit: 2
"text":"mit Bibliothek"

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

grep -c '^source .*/lib/lib.sh"$' ~/sh-lab/werkzeug/bin/notes-ping \
  ~/sh-lab/werkzeug/bin/notes-add

Erwartet:

/home/ubuntu/sh-lab/werkzeug/bin/notes-ping:1
/home/ubuntu/sh-lab/werkzeug/bin/notes-add:1
bash -c 'source ~/sh-lab/werkzeug/lib/lib.sh; need curl gibtsnicht'; echo "Exit: $?"

Erwartet:

12:22:40 bash: FEHLER Programm fehlt: gibtsnicht
Exit: 3
shellcheck -x ~/sh-lab/werkzeug/bin/* && echo "alles sauber"

Erwartet:

alles sauber

Challenge

Ergänze lib.sh um retry anzahl befehl…: Es führt den Befehl aus, bis er klappt, höchstens anzahl-mal mit einer Sekunde Pause, meldet jeden Fehlversuch mit warn und endet mit dem Exit-Code des letzten Versuchs.

Hinweis: "$@" nach einem shift sind genau die Wörter des Befehls.

Lösung

cat >> ~/sh-lab/werkzeug/lib/lib.sh <<'EOF'

# retry anzahl befehl…  – wiederholt einen Befehl, bis er klappt
retry() {
  local max=$1 versuch=1 rc
  shift
  while true; do
    rc=0
    "$@" || rc=$?
    ((rc == 0)) && return 0
    ((versuch >= max)) && return "$rc"
    warn "Versuch $versuch/$max: $* (Exit $rc)"
    versuch=$((versuch + 1))
    sleep 1
  done
}
EOF
shellcheck ~/sh-lab/werkzeug/lib/lib.sh && echo sauber
bash -c 'source ~/sh-lab/werkzeug/lib/lib.sh; retry 3 false; echo "Exit: $?"'
bash -c 'source ~/sh-lab/werkzeug/lib/lib.sh; retry 3 notes-ping'

Erwartet:

sauber
12:24:01 bash: WARN Versuch 1/3: false (Exit 1)
12:24:02 bash: WARN Versuch 2/3: false (Exit 1)
Exit: 1
notes ok

"$@" || rc=$? hält den Exit-Code fest, ohne dass set -e abbricht – im Skript, das retry benutzt, gilt ja der strenge Modus.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Eine Bibliothek, versioniert: Gemeinsame Funktionen liegen einmal im Repository und werden mitverteilt. Kopien in jedem Skript laufen auseinander.
  • Einheitliches Logging: Zeitstempel, Programmname und Stufe auf stderr – dann versteht journald, cron-Mail oder ein Log-Sammler jede Zeile gleich.
  • set -x in Produktion nur gezielt: Die Ablaufverfolgung zeigt auch Secrets, die in Variablen stehen.