bash: come propagare errori nella sostituzione del processo?

Voglio che i miei script di shell falliscano ogni volta che un comando eseguito con loro fallisce.

In genere lo faccio con:

set -e
set -o pipefail

(in genere aggiungo set -uanche io )

Il fatto è che nessuna delle precedenti funziona con la sostituzione del processo. Questo codice stampa "ok" ed esce con codice di ritorno = 0, mentre vorrei che fallisse:

#!/bin/bash -e
set -o pipefail
cat <(false) <(echo ok)

Esiste qualcosa di equivalente a "pipefail" se non per la sostituzione del processo? Qualche altro modo per passare a un comando l'output dei comandi come se fossero file, ma generando un errore ogni volta che uno di questi programmi fallisce?

La soluzione di un uomo povero sarebbe rilevare se quei comandi scrivono a stderr (ma alcuni comandi scrivono a stderr in scenari di successo).

Un'altra soluzione più conforme a posix sarebbe l'uso di named pipe, ma ho bisogno di lanciare quei comandi che usano la sostituzione del processo come oneliners costruiti al volo dal codice compilato, e la creazione di named pipe complicherà le cose (comandi extra, errore di intrappolamento per eliminandoli, ecc.)

Ad esempio, potresti solo aggirare quel problema:

cat <(false || kill $$) <(echo ok)
other_command

La subshell dello script è SIGTERMd prima che il secondo comando possa essere eseguito ( other_command). Il echo okcomando viene eseguito "a volte": il problema è che le sostituzioni di processo sono asincrone. Non è garantito che il kill $$comando sia eseguito prima o dopo il echo okcomando. È una questione di pianificazione dei sistemi operativi.

Considera uno script bash come questo:

#!/bin/bash
set -e
set -o pipefail
cat <(echo pre) <(false || kill $$) <(echo post)
echo "you will never see this"

L'output di quello script può essere:

$ ./script
Terminated
$ echo $?
143           # it's 128 + 15 (signal number of SIGTERM)

O:

$ ./script
Terminated
$ pre
post

$ echo $?
143

Puoi provarlo e dopo alcuni tentativi, vedrai i due diversi ordini nell'output. Nel primo lo script è stato terminato prima che gli altri due echocomandi potessero scrivere nel descrittore di file. Nel secondo falseil killcomando o era probabilmente programmato dopo i echocomandi.

O per essere più precisi: la chiamata signal()di sistema killdell'utilità che invia il SIGTERMsegnale al processo di shell è stata programmata (o consegnata) più tardi o prima delle ecoscandagli write()dell'eco.

Tuttavia, lo script si interrompe e il codice di uscita non è 0. Dovrebbe quindi risolvere il problema.

Un'altra soluzione è, ovviamente, utilizzare pipe denominate per questo. Ma dipende dal tuo script quanto sia complesso implementare named pipe o la soluzione alternativa sopra.

Riferimenti:

• http://mywiki.wooledge.org/BashFAQ/106
• http://mywiki.wooledge.org/RaceCondition
• http://lists.gnu.org/archive/html/bug-bash/2010-09/msg00017.html

Per la cronaca, e anche se le risposte e i commenti erano buoni e utili, ho finito di implementare qualcosa di leggermente diverso (avevo alcune restrizioni sulla ricezione di segnali nel processo genitore che non avevo menzionato nella domanda)

Fondamentalmente, ho finito per fare qualcosa del genere:

command <(subcomand 2>error_file && rm error_file) <(....) ...

Quindi controllo il file di errore. Se esiste, so quale sottocomando non è riuscito (e il contenuto del file_errore può essere utile). Più prolisso e incisivo che inizialmente desideravo, ma meno ingombrante rispetto alla creazione di pipe con nome in un comando bash da una riga.

Questo esempio mostra come usare killinsieme a trap.

#! /bin/bash
failure ()
{
  echo 'sub process failed' >&2
  exit 1
}
trap failure SIGUSR1
cat < <( false || kill -SIGUSR1 $$ )

Ma killnon è possibile passare un codice di ritorno dal processo secondario al processo principale.

In un modo simile a quello che avresti implementato $PIPESTATUS/ $pipestatuscon una shell POSIX che non lo supporta , puoi ottenere lo stato di uscita dei comandi facendoli passare attraverso una pipe:

unset -v false_status echo_status
{ code=$(
    exec 3>&1 >&4 4>&-
    cat 3>&- <(false 3>&-; echo >&3 "false_status=$?") \
             <(echo ok 3>&-; echo >&3 "echo_status=$?")
);} 4>&1
cat_status=$?
eval "$code"
printf '%s_code=%d\n' cat   "$cat_status" \
                      false "$false_status" \
                      echo  "$echo_status"

Che dà:

ok
cat_code=0
false_code=1
echo_code=0

Oppure potresti usare pipefaile implementare la sostituzione dei processi a mano come faresti con le shell che non lo supportano:

set -o pipefail
{
  false <&5 5<&- | {
    echo OK <&5 5<&- | {
      cat /dev/fd/3 /dev/fd/4
    } 4<&0 <&5 5<&-
  } 3<&0
} 5<&0