Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 12: Prozesse und Signale

Ziel: Befehle im Hintergrund starten und auf sie warten, Arbeit parallelisieren, Laufzeiten begrenzen und auf Signale reagieren. Am Ende überwacht notes-watch notes dauerhaft, endet sauber auf TERM und meldet sich auf USR1. · Dauer: ca. 90 min · Voraussetzung: Tag 11

Briefing

  • befehl & startet im Hintergrund, $! ist seine Prozess-ID (PID), wait $pid wartet auf ihn und liefert seinen Exit-Code.
  • timeout 5 befehl bricht nach fünf Sekunden ab (Exit-Code 124).
  • Signale sind Nachrichten an Prozesse: TERM (bitte beenden), INT (Strg+C), KILL (sofort, nicht abfangbar), HUP, USR1/USR2 (frei verwendbar). trap '…' TERM legt fest, was ein Skript bei einem Signal tut.
  • Ein Dienst-Skript beendet sich auf TERM geordnet: laufende Arbeit fertig, aufräumen, Abschlussmeldung. systemd, Docker und Kubernetes schicken genau TERM.
 notes-watch -i 2 &           ─► alle 2 s notes-ping, meldet Zustandswechsel
   kill -USR1 <pid>           ─► „Statistik: 7 Prüfungen, 0 Fehler"
   kill -TERM <pid>           ─► Schleife endet, „beendet nach 9 Prüfungen"

Drill 1: Hintergrund und wait

source ~/sh-lab/setup/env.sh
mkdir -p ~/sh-lab/tag12 && cd ~/sh-lab/tag12
sleep 2 & p1=$!
(sleep 1; exit 3) & p2=$!
echo "gestartet: $(jobs -p | wc -l) Jobs"
wait "$p2"; echo "Job 2 endete mit $?"
wait "$p1"; echo "Job 1 endete mit $?"
jobs -p | wc -l

Erwartet:

gestartet: 2 Jobs
Job 2 endete mit 3
Job 1 endete mit 0
0

wait ohne Argument wartet auf alle Hintergrundjobs, liefert aber nur den Exit-Code des letzten. Wer wissen will, ob jeder Job geklappt hat, merkt sich die PIDs und fragt einzeln.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Parallel prüfen

cat > parallel <<'EOF'
#!/usr/bin/env bash
set -euo pipefail
pruefe() { curl -fsS -o /dev/null --max-time 3 "$NOTES_URL$1" 2>/dev/null; }

declare -A pid
for e in /healthz /notes /version /admin; do
  pruefe "$e" & pid[$e]=$!
done
fehler=0
for e in "${!pid[@]}"; do
  if wait "${pid[$e]}"; then echo "ok     $e"; else echo "FEHLER $e"; fehler=1; fi
done | sort
exit "$fehler"
EOF
bash parallel; echo "Exit: $?"

Erwartet:

parallel: line 11: wait: pid 6996 is not a child of this shell
parallel: line 11: wait: pid 6998 is not a child of this shell
parallel: line 11: wait: pid 6995 is not a child of this shell
parallel: line 11: wait: pid 6997 is not a child of this shell
FEHLER /admin
FEHLER /healthz
FEHLER /notes
FEHLER /version
Exit: 0

Alles falsch – und trotzdem Exit 0. Wegen | sort läuft die zweite for-Schleife in einer Unter-Shell. Die vier curl sind aber Kinder der Haupt-Shell, nicht der Unter-Shell, also kann wait dort nicht auf sie warten. Und fehler=1 geht in der Unter-Shell ohnehin verloren. Der Klassiker aus Tag 3, diesmal gut versteckt. Die Lösung: erst in der Haupt-Shell sammeln, dann sortieren.

sed -i 's/^done | sort$/done > ergebnis.txt\nsort ergebnis.txt/' parallel
bash parallel; echo "Exit: $?"

Erwartet:

FEHLER /admin
ok     /healthz
ok     /notes
ok     /version
Exit: 1

Fortschritt speichern? Kostenlos registrieren

Drill 3: timeout

timeout 1 sleep 5; echo "Exit: $?"
timeout -s USR1 1 bash -c 'trap "echo USR1 erhalten; exit 0" USR1; sleep 5 & wait'
echo "Exit: $?"
timeout -k 1 1 bash -c 'trap "" TERM; sleep 5'; echo "Exit: $?"

Erwartet:

Exit: 124
USR1 erhalten
Exit: 124
Exit: 137
  • timeout schickt nach Ablauf TERM (mit -s ein anderes Signal) und endet mit 124.
  • Ignoriert ein Prozess das Signal (trap "" TERM), schickt -k 1 eine Sekunde später KILL. 137 = 128 + 9 (KILL): Exit-Codes über 128 heißen „durch Signal beendet”.
  • sleep 5 & wait: Bash führt Traps erst aus, wenn der laufende Vordergrundbefehl fertig ist. wait dagegen wird von Signalen sofort unterbrochen – deshalb dieses Muster in jedem Skript, das auf Signale reagieren soll.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Signale abfangen

cat > signale <<'EOF'
#!/usr/bin/env bash
set -euo pipefail
trap 'echo "USR1: noch da"' USR1
trap 'echo "TERM: räume auf und gehe"; exit 0' TERM
echo "PID $$ wartet"
while true; do sleep 1 & wait $! || true; done
EOF
bash signale > signale.log & p=$!
sleep 1; kill -USR1 "$p"; sleep 1; kill -TERM "$p"; wait "$p"; echo "Exit: $?"
cat signale.log | sed -E 's/PID [0-9]+/PID …/'
kill -l | head -2

Erwartet:

Exit: 0
PID … wartet
USR1: noch da
TERM: räume auf und gehe
 1) SIGHUP   2) SIGINT   3) SIGQUIT  4) SIGILL   5) SIGTRAP
 6) SIGABRT  7) SIGBUS   8) SIGFPE   9) SIGKILL 10) SIGUSR1

kill heißt nur so – es schickt Signale, standardmäßig TERM. wait $! || true: Ein Signal unterbricht wait mit einem Code über 128, und set -e soll deshalb nicht abbrechen.

Fortschritt speichern? Kostenlos registrieren

Drill 5: notes-watch

cat > ~/sh-lab/werkzeug/bin/notes-watch <<'EOF'
#!/usr/bin/env bash
# notes-watch – überwacht notes: notes-watch [-i sekunden]
# Signale: TERM/INT beenden geordnet, USR1 meldet die Statistik
set -euo pipefail
source "$(dirname "$(readlink -f "${BASH_SOURCE[0]}")")/../lib/lib.sh"
intervall=5
while getopts ":i:h" opt; do
  case "$opt" in
    i) intervall="$OPTARG" ;;
    h)
      echo "Aufruf: $PROG [-i sekunden]"
      exit 0
      ;;
    *) die "falsche Option (Hilfe: -h)" 2 ;;
  esac
done
[[ $intervall =~ ^[1-9][0-9]*$ ]] || die "-i braucht eine Zahl ≥ 1" 2

pruefungen=0
fehler=0
letzter=""
stop=0
trap 'stop=1' TERM INT
trap 'info "Statistik: $pruefungen Prüfungen, $fehler Fehler"' USR1

info "gestartet (PID $$, alle ${intervall}s)"
while ((! stop)); do
  if notes-ping >/dev/null 2>&1; then
    zustand=ok
  else
    zustand=fehler
    fehler=$((fehler + 1))
  fi
  pruefungen=$((pruefungen + 1))
  if [[ $zustand != "$letzter" ]]; then info "Zustand: $zustand"; fi
  letzter=$zustand
  sleep "$intervall" &
  wait $! || true
done
info "beendet nach $pruefungen Prüfungen"
EOF
chmod +x ~/sh-lab/werkzeug/bin/notes-watch
cd ~/sh-lab/werkzeug && ./ci.sh | tail -1 && cd ~/sh-lab/tag12
notes-watch -i 1 2> watch.log & w=$!
sleep 2.5
docker compose -f ~/sh-lab/notes/compose.yaml stop proxy >/dev/null 2>&1
sleep 2
docker compose -f ~/sh-lab/notes/compose.yaml start proxy >/dev/null 2>&1
sleep 2
kill -USR1 "$w"; sleep 0.5; kill -TERM "$w"; wait "$w"; echo "Exit: $?"
sed -E 's/^[0-9:]{8}/…/; s/PID [0-9]+/PID …/' watch.log \
  | sed -E 's/[0-9]+ (Prüfungen|Fehler)/n \1/g'

Erwartet:

ci: alles grün
Exit: 0
… notes-watch: INFO gestartet (PID …, alle 1s)
… notes-watch: INFO Zustand: ok
… notes-watch: INFO Zustand: fehler
… notes-watch: INFO Zustand: ok
… notes-watch: INFO Statistik: n Prüfungen, n Fehler
… notes-watch: INFO beendet nach n Prüfungen
  • trap 'stop=1' TERM INT beendet nicht sofort, sondern setzt nur eine Marke. Die Schleife prüft sie und endet nach dem laufenden Durchgang – mitten in einer Prüfung wird nichts abgebrochen.
  • Gemeldet wird nur ein Wechsel des Zustands, nicht jede Prüfung. So bleibt das Log lesbar.
  • Wie viele Prüfungen scheiterten, hängt davon ab, wie lange der Proxy weg war.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

timeout 3 notes-watch -i 1 2>&1 | grep -c 'Zustand: ok'

Erwartet: timeout schickt nach drei Sekunden TERM, die Schleife endet geordnet.

1
notes-watch -i 0; echo "Exit: $?"

Erwartet:

13:10:02 notes-watch: FEHLER -i braucht eine Zahl ≥ 1
Exit: 2
bash -c 'sleep 10 & kill -KILL $!; wait $!; echo "Exit: $?"'

Erwartet:

bash: line 1: 7007 Killed                     sleep 10
Exit: 137

Challenge

Für Tests soll notes-watch nach einer festen Zahl von Prüfungen von selbst aufhören: notes-watch -i 1 -n 3 prüft dreimal und endet mit Exit-Code 0.

Hinweis: Option n: in getopts, Standard 0 heißt „unbegrenzt”, und eine weitere Bedingung am Ende der Schleife.

Lösung

cd ~/sh-lab/werkzeug/bin
f=notes-watch
sed -i 's/":i:h"/":i:n:h"/' $f
sed -i 's/^    i) intervall="\$OPTARG" ;;$/&\n    n) anzahl="$OPTARG" ;;/' $f
sed -i 's/^intervall=5$/&\nanzahl=0/' $f
neu='  ((anzahl > 0 \&\& pruefungen >= anzahl)) \&\& break'
sed -i "s/^  pruefungen=\$((pruefungen + 1))\$/&\n$neu/" $f
sed -i 's/\[-i sekunden\]"/[-i sekunden] [-n anzahl]"/' $f
grep -n 'anzahl' $f
TIMEFORMAT='%1Rs'
time (notes-watch -i 1 -n 3 2>&1 | grep -c Zustand)
cd ~/sh-lab/werkzeug && ./ci.sh | tail -1

Erwartet:

7:anzahl=0
11:    n) anzahl="$OPTARG" ;;
13:      echo "Aufruf: $PROG [-i sekunden] [-n anzahl]"
37:  ((anzahl > 0 && pruefungen >= anzahl)) && break
1
2.3s
ci: alles grün

Drei Prüfungen, aber nur zwei Pausen: Nach der dritten verlässt break die Schleife sofort. Ein &&-Ausdruck, der scheitert, bricht trotz set -e nicht ab – er ist ja eine Bedingung.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • PID 1 im Container: Läuft ein Skript als Hauptprozess eines Containers, bekommt es TERM von docker stop – und hat 10 Sekunden, bevor KILL folgt. Ohne trap und das sleep & wait-Muster wird es immer hart beendet.
  • Kinder mitbeenden: Ein Skript, das Hintergrundjobs startet, sollte sie in seinem EXIT-Trap beenden: trap 'kill $(jobs -p) 2>/dev/null' EXIT.
  • Lieber systemd als Endlosschleife: Ein dauerhafter Wächter läuft als systemd-Dienst mit Restart=on-failure; für regelmäßige Prüfungen ist ein Timer (Tag 13) oft die bessere Wahl als while true.