Captura de códigos de error en una tubería de shell

Actualmente tengo un script que hace algo como

./a | ./b | ./c

Quiero modificarlo para que si alguno de a, bo c sale con un código de error, imprimo un mensaje de error y me detengo en lugar de enviar una salida incorrecta.

¿Cuál sería la forma más sencilla / limpia de hacerlo?

Si realmente no desea que el segundo comando continúe hasta que se sepa que el primero es exitoso, entonces probablemente necesite usar archivos temporales. La versión simple de eso es:

tmp=${TMPDIR:-/tmp}/mine.$$
if ./a > $tmp.1
then
    if ./b <$tmp.1 >$tmp.2
    then
        if ./c <$tmp.2
        then : OK
        else echo "./c failed" 1>&2
        fi
    else echo "./b failed" 1>&2
    fi
else echo "./a failed" 1>&2
fi
rm -f $tmp.[12]

La redirección '1> & 2' también se puede abreviar '> & 2'; sin embargo, una versión anterior del shell MKS manejó mal la redirección de errores sin el '1' anterior, por lo que he usado esa notación inequívoca para la confiabilidad durante años.

Esto filtra archivos si interrumpe algo. Usos de programación de shell a prueba de bombas (más o menos):

tmp=${TMPDIR:-/tmp}/mine.$$
trap 'rm -f $tmp.[12]; exit 1' 0 1 2 3 13 15
...if statement as before...
rm -f $tmp.[12]
trap 0 1 2 3 13 15

La primera línea de trampa dice 'ejecutar los comandos' rm -f $tmp.[12]; exit 1'cuando ocurre alguna de las señales 1 SIGHUP, 2 SIGINT, 3 SIGQUIT, 13 SIGPIPE o 15 SIGTERM, o 0 (cuando el shell sale por cualquier motivo). Si está escribiendo un script de shell, la trampa final solo necesita eliminar la trampa en 0, que es la trampa de salida de shell (puede dejar las otras señales en su lugar ya que el proceso está a punto de terminar de todos modos).

En la canalización original, es factible que 'c' lea datos de 'b' antes de que 'a' haya terminado; esto suele ser deseable (por ejemplo, da trabajo a varios núcleos). Si 'b' es una fase de 'clasificación', entonces esto no se aplicará; 'b' tiene que ver todas sus entradas antes de poder generar cualquiera de sus salidas.

Si desea detectar qué comando (s) fallan, puede usar:

(./a || echo "./a exited with $?" 1>&2) |
(./b || echo "./b exited with $?" 1>&2) |
(./c || echo "./c exited with $?" 1>&2)

Esto es simple y simétrico: es trivial extenderlo a una tubería de 4 o N partes.

La simple experimentación con 'set -e' no ayudó.

En bash puedes usar set -ey set -o pipefailal principio de tu archivo. Un comando posterior ./a | ./b | ./cfallará cuando falla cualquiera de los tres scripts. El código de retorno será el código de retorno del primer script fallido.

Tenga en cuenta que pipefailno está disponible en sh estándar .

También puede verificar la ${PIPESTATUS[]}matriz después de la ejecución completa, por ejemplo, si ejecuta:

./a | ./b | ./c

Luego ${PIPESTATUS}habrá una matriz de códigos de error de cada comando en la tubería, por lo que si el comando del medio falla, echo ${PIPESTATUS[@]}contendrá algo como:

0 1 0

y algo como esto se ejecuta después del comando:

test ${PIPESTATUS[0]} -eq 0 -a ${PIPESTATUS[1]} -eq 0 -a ${PIPESTATUS[2]} -eq 0

le permitirá comprobar que todos los comandos de la tubería se ejecutaron correctamente.

Desafortunadamente, la respuesta de Johnathan requiere archivos temporales y las respuestas de Michel e Imron requieren bash (aunque esta pregunta está etiquetada como shell). Como ya han señalado otros, no es posible abortar la tubería antes de que se inicien procesos posteriores. Todos los procesos se inician a la vez y, por lo tanto, se ejecutarán antes de que se pueda comunicar cualquier error. Pero el título de la pregunta también preguntaba sobre códigos de error. Estos se pueden recuperar e investigar después de que la tubería terminó para determinar si alguno de los procesos involucrados falló.

Aquí hay una solución que detecta todos los errores en la tubería y no solo los errores del último componente. Así que esto es como el error de tubería de bash, solo que más poderoso en el sentido de que puede recuperar todos los códigos de error.

res=$( (./a 2>&1 || echo "1st failed with $?" >&2) |
(./b 2>&1 || echo "2nd failed with $?" >&2) |
(./c 2>&1 || echo "3rd failed with $?" >&2) > /dev/null 2>&1)
if [ -n "$res" ]; then
    echo pipe failed
fi

Para detectar si algo falló, se echoimprime un comando en el error estándar en caso de que falle algún comando. Luego, la salida de error estándar combinada se guarda $resy se investiga más tarde. Esta es también la razón por la que el error estándar de todos los procesos se redirige a la salida estándar. También puede enviar esa salida /dev/nullo dejarla como otro indicador más de que algo salió mal. Puede reemplazar la última redirección a /dev/nullcon un archivo si desea almacenar la salida del último comando en cualquier lugar.

Para jugar más con esta construcción y convencerte de que realmente hace lo que debería, reemplacé ./a, ./by ./cpor subcapas que se ejecutan echo, caty exit. Puede usar esto para verificar que esta construcción realmente reenvía toda la salida de un proceso a otro y que los códigos de error se registran correctamente.

res=$( (sh -c "echo 1st out; exit 0" 2>&1 || echo "1st failed with $?" >&2) |
(sh -c "cat; echo 2nd out; exit 0" 2>&1 || echo "2nd failed with $?" >&2) |
(sh -c "echo start; cat; echo end; exit 0" 2>&1 || echo "3rd failed with $?" >&2) > /dev/null 2>&1)
if [ -n "$res" ]; then
    echo pipe failed
fi