120 lines
5.2 KiB
Bash
120 lines
5.2 KiB
Bash
#!/usr/bin/env bash
|
|
# ==============================================================================
|
|
# Bash 10: Prozess-Substitution, Named Pipes & Co-Prozesse (coproc)
|
|
# ==============================================================================
|
|
# In diesem Modul lernst du fortschrittliche Linux IPC-Mechanismen:
|
|
# Process Substitution <(...), Stream-Fächerung >(...), Named Pipes (mkfifo)
|
|
# und interaktive Co-Prozesse (coproc).
|
|
# ==============================================================================
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# TODO 1: Befehlsausgaben ohne temporäre Dateien vergleichen (<(...))
|
|
# ------------------------------------------------------------------------------
|
|
# Implementiere die Funktion `compare_command_outputs`.
|
|
# Parameter:
|
|
# $1: Erster Bash-Befehl als String (z.B. "sort liste1.txt")
|
|
# $2: Zweiter Bash-Befehl als String (z.B. "sort liste2.txt")
|
|
# Verhalten:
|
|
# - Vergleicht die Ausgaben beider Befehle direkt mit `diff -u` und Prozess-Substitution:
|
|
# diff -u <(bash -c "$1") <(bash -c "$2")
|
|
# - Wenn beide Ausgaben identisch sind: Gib "IDENTICAL" aus und return 0.
|
|
# - Wenn Unterschiede existieren: Gib den Diff aus und return 1.
|
|
# ------------------------------------------------------------------------------
|
|
compare_command_outputs() {
|
|
local cmd1="${1:-}"
|
|
local cmd2="${2:-}"
|
|
|
|
# TODO: Prüfe Parameter
|
|
# TODO: Führe diff -u mit <(bash -c "$cmd1") und <(bash -c "$cmd2") aus
|
|
echo "TODO: Implementiere compare_command_outputs"
|
|
return 1
|
|
}
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# TODO 2: Stream-Verzweigung mit tee & >(...)
|
|
# ------------------------------------------------------------------------------
|
|
# Implementiere die Funktion `stream_splitter_tee`.
|
|
# Parameter:
|
|
# $1: Eingabetext (z.B. "Fehler: Connection Timeout auf DB-Server")
|
|
# $2: Pfad zur Roh-Logdatei (z.B. "/tmp/raw.log")
|
|
# $3: Pfad zur transformierten Datei (z.B. "/tmp/uppercase.log")
|
|
# Verhalten:
|
|
# - Schreibt den Eingabetext unverändert in $2.
|
|
# - Leitet den Text gleichzeitig über Prozess-Substitution `>(tr '[:lower:]' '[:upper:]' > "$3")`
|
|
# in Großbuchstaben nach $3 um (mit `tee`).
|
|
# - Wartet kurz/synchronisiert, sodass beide Dateien vollständig geschrieben sind.
|
|
# - Return 0 bei Erfolg.
|
|
# ------------------------------------------------------------------------------
|
|
stream_splitter_tee() {
|
|
local input_text="${1:-}"
|
|
local raw_file="${2:-}"
|
|
local upper_file="${3:-}"
|
|
|
|
# TODO: Validiere Parameter
|
|
# TODO: Nutze echo "$input_text" | tee "$raw_file" >(tr '[:lower:]' '[:upper:]' > "$upper_file") > /dev/null
|
|
echo "TODO: Implementiere stream_splitter_tee"
|
|
return 1
|
|
}
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# TODO 3: Interprozesskommunikation über Named Pipe (FIFO)
|
|
# ------------------------------------------------------------------------------
|
|
# Implementiere die Funktion `named_pipe_transfer`.
|
|
# Parameter:
|
|
# $1: Pfad zur Named Pipe (z.B. "/tmp/test_fifo")
|
|
# $2: Zu übertragende Nachricht (z.B. "DEPLOYMENT_TRIGGER_V2")
|
|
# Verhalten:
|
|
# - Erstellt eine Named Pipe mit `mkfifo "$1"`. Falls die Pipe existiert, vorher löschen.
|
|
# - Schreibt im Hintergrund (`&`) die Nachricht $2 in die Pipe.
|
|
# - Liest im Hauptprozess die Nachricht aus der Pipe in eine Variable `received`.
|
|
# - Löscht die Pipe nach erfolgreichem Lesen (`rm -f "$1"`).
|
|
# - Gibt aus: "RECEIVED_FIFO: $received"
|
|
# - Return 0.
|
|
# ------------------------------------------------------------------------------
|
|
named_pipe_transfer() {
|
|
local fifo_path="${1:-}"
|
|
local message="${2:-}"
|
|
|
|
# TODO: Erstelle FIFO mit mkfifo
|
|
# TODO: Schreibe im Hintergrund ($message > $fifo_path &)
|
|
# TODO: Lies synchron (read -r received < $fifo_path)
|
|
# TODO: Bereinige FIFO und gib "RECEIVED_FIFO: $received" aus
|
|
echo "TODO: Implementiere named_pipe_transfer"
|
|
return 1
|
|
}
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# TODO 4: Interaktiver Co-Prozess (coproc)
|
|
# ------------------------------------------------------------------------------
|
|
# Implementiere die Funktion `coproc_calculator_interactive`.
|
|
# Parameter:
|
|
# $1: Erster mathematischer Ausdruck (z.B. "10 + 25")
|
|
# $2: Zweiter mathematischer Ausdruck (z.B. "100 * 4")
|
|
# Verhalten:
|
|
# - Startet einen Co-Prozess namens CALC mit Bash:
|
|
# coproc CALC {
|
|
# while read -r expr; do
|
|
# [ "$expr" = "EXIT" ] && break
|
|
# echo "$((expr))"
|
|
# done
|
|
# }
|
|
# - Sendet $1 an den Co-Prozess (`${CALC[1]}`), liest das Ergebnis aus (`${CALC[0]}`).
|
|
# - Sendet $2 an den Co-Prozess, liest das zweite Ergebnis aus.
|
|
# - Sendet "EXIT" an den Co-Prozess zum sauberen Beenden.
|
|
# - Gibt die Ergebnisse aus:
|
|
# CALC_RES1: <ergebnis1>
|
|
# CALC_RES2: <ergebnis2>
|
|
# - Return 0.
|
|
# ------------------------------------------------------------------------------
|
|
coproc_calculator_interactive() {
|
|
local expr1="${1:-}"
|
|
local expr2="${2:-}"
|
|
|
|
# TODO: Starte coproc CALC
|
|
# TODO: Sende expr1, lies res1
|
|
# TODO: Sende expr2, lies res2
|
|
# TODO: Sende EXIT
|
|
# TODO: Gib formatiertes Ergebnis aus
|
|
echo "TODO: Implementiere coproc_calculator_interactive"
|
|
return 1
|
|
}
|