pipe stdout y stderr a dos procesos diferentes en shell script?

La respuesta aceptada resulta en la inversión de stdout y stderr. Aquí hay un método que los preserva (ya que Googlear con ese propósito trae este post):

{ command 2>&1 1>&3 3>&- | stderr_command; } 3>&1 1>&2 | stdout_command

Aviso:

• 3>&- es necesario para evitar que fd 3 sea heredado por command. (Ya que esto puede llevar a resultados inesperados dependiendo de lo que command hace dentro.)

Partes explicadas: {[43]]}

1. Primera parte exterior:

   1. 3>&1 -- fd 3 para {[9] } se establece en lo que fd 1 era (es decir, stdout)
   2. 1>&2 -- fd 1 para { ... } se establece en lo que fd 2 era (es decir, stderr)
   3. | stdout_command -- fd 1 (was stdout) se canaliza a través de stdout_command

2. La parte interna hereda los descriptores de archivo de la parte externa:

   1. 2>&1 -- fd 2 para command se establece en lo que fd 1 era (es decir, stderr según la parte exterior)
   2. 1>&3 -- fd 1 para {[6] } se establece en lo que fd 3 era (es decir, stdout según la parte exterior)
   3. 3>&- -- fd 3 para command se establece en nada (es decir, cerrado)
   4. | stderr_command -- fd 1 (was stderr) se canaliza a través de stderr_command

Ejemplo:

foo() {
    echo a
    echo b >&2
    echo c
    echo d >&2
}

{ foo 2>&1 1>&3 3>&- | sed -u 's/^/err: /'; } 3>&1 1>&2 | sed -u 's/^/out: /'

Salida:

out: a
err: b
err: d
out: c

(El orden de a -> c y b -> d siempre será indeterminado porque no hay forma de sincronización entre stderr_command y stdout_command.)

Simplemente redirija stderr a stdout

{ command1 | command2; } 2>&1 | command3

Precaución: commnd3 también se leerá command2 stdout (si existe).
Para evitar eso, puedes descartar commnd2 stdout:

{ command1 | command2 >/dev/null; } 2>&1 | command3

Sin embargo, para mantener command2 stdout (por ejemplo, en la terminal),
entonces por favor refiérase a mi otra respuesta más compleja.

Prueba

{ { echo -e "a\nb\nc" >&2; echo "----"; } | sed 's/$/1/'; } 2>&1 | sed 's/$/2/'

Salida:

a2
b2
c2
----12

Usando la sustitución de procesos:

command1 > >(command2) 2> >(command3)

Véase http://tldp.org/LDP/abs/html/process-sub.html para más información.

El mismo efecto se puede lograr con bastante facilidad con un fifo. No soy consciente de una sintaxis de tubería directa para hacerlo (aunque sería ingenioso ver una). Así es como puedes hacerlo con un fifo.

Primero, algo que imprime a ambos stdout y stderr, outerr.sh:

#!/bin/bash

echo "This goes to stdout"
echo "This goes to stderr" >&2

, Entonces podemos hacer algo como esto:

$ mkfifo err
$ wc -c err &
[1] 2546
$ ./outerr.sh 2>err | wc -c
20
20 err
[1]+  Done                    wc -c err

De esta manera se configura el oyente para la salida stderr primero y se bloquea hasta que tiene un escritor, lo que sucede en el siguiente comando, utilizando la sintaxis 2>err. Puedes ver que cada wc -c tiene 20 caracteres de entrada.

No te olvides de limpiar el fifo después de que hayas terminado si no quieres que se quede (es decir, rm). Si el otro comando quiere entrada en stdin y no un archivo arg, puede usar la redirección de entrada como wc -c < err también.