¿Cómo puedo canalizar stderr y no stdout?

Tengo un programa que escribe información en stdouty stderr, y necesito hacerlo a greptravés de lo que viene a stderr , sin tener en cuenta stdout .

Por supuesto que puedo hacerlo en 2 pasos:

command > /dev/null 2> temp.file
grep 'something' temp.file

pero preferiría poder hacer esto sin archivos temporales. ¿Hay algún truco de tubería inteligente?

Primero redirige stderr a stdout: la tubería; luego redirija stdout a /dev/null(sin cambiar a dónde va stderr):

command 2>&1 >/dev/null | grep 'something'

Para obtener detalles sobre la redirección de E / S en toda su variedad, consulte el capítulo sobre redirecciones en el manual de referencia de Bash.

Tenga en cuenta que la secuencia de redireccionamientos de E / S se interpreta de izquierda a derecha, pero las tuberías se configuran antes de que se interpreten las redirecciones de E / S. Los descriptores de archivos como 1 y 2 son referencias a descripciones de archivos abiertos. La operación 2>&1hace que el descriptor de archivo 2 también conocido como stderr se refiera a la misma descripción de archivo abierto que el descriptor de archivo 1 al que stdout se refiere actualmente (ver dup2()y open()). La operación >/dev/nullluego cambia el descriptor de archivo 1 para que se refiera a una descripción de archivo abierto /dev/null, pero eso no cambia el hecho de que el descriptor de archivo 2 se refiere a la descripción de archivo abierto a la que el descriptor de archivo 1 apuntaba originalmente, es decir, la tubería.

O para intercambiar la salida del error estándar y la salida estándar, use:

command 3>&1 1>&2 2>&3

Esto crea un nuevo descriptor de archivo (3) y lo asigna al mismo lugar que 1 (salida estándar), luego asigna fd 1 (salida estándar) al mismo lugar que fd 2 (error estándar) y finalmente asigna fd 2 (error estándar ) al mismo lugar que fd 3 (salida estándar).

El error estándar ahora está disponible como salida estándar y la salida estándar anterior se conserva en error estándar. Esto puede ser excesivo, pero esperamos que brinde más detalles sobre los descriptores de archivos Bash (hay nueve disponibles para cada proceso).

En Bash, también puede redirigir a una subshell utilizando la sustitución de procesos :

command > >(stdlog pipe)  2> >(stderr pipe)

Para el caso en cuestión:

command 2> >(grep 'something') >/dev/null

Combinando la mejor de estas respuestas, si lo haces:

command 2> >(grep -v something 1>&2)

... entonces todo stdout se conserva como stdout y todo stderr se conserva como stderr, pero no verá ninguna línea en stderr que contenga la cadena "algo".

Esto tiene la ventaja única de no revertir o descartar stdout y stderr, ni eliminarlos juntos, ni usar ningún archivo temporal.

Es mucho más fácil visualizar las cosas si piensas en lo que realmente está sucediendo con los "redireccionamientos" y las "canalizaciones". Los redireccionamientos y las canalizaciones en bash hacen una cosa: modificar dónde apuntan los descriptores de archivo de proceso 0, 1 y 2 (ver / proc / [pid] / fd / *).

Cuando una tubería o "|" El operador está presente en la línea de comando, lo primero que sucede es que bash crea un fifo y señala el FD 1 del comando del lado izquierdo a este fifo, y apunta el FD 0 del comando del lado derecho al mismo fifo.

A continuación, los operadores de redireccionamiento para cada lado se evalúan de izquierda a derecha , y la configuración actual se utiliza cada vez que se produce la duplicación del descriptor. Esto es importante porque, dado que la tubería se configuró primero, el FD1 (lado izquierdo) y el FD0 (lado derecho) ya han cambiado de lo que podrían haber sido normalmente, y cualquier duplicación de estos reflejará ese hecho.

Por lo tanto, cuando escribe algo como lo siguiente:

command 2>&1 >/dev/null | grep 'something'

Esto es lo que sucede, en orden:

1. se crea una tubería (fifo). El "comando FD1" apunta a esta tubería. "grep FD0" también apunta a esta tubería
2. "comando FD2" apunta a donde "comando FD1" apunta actualmente (la tubería)
3. "comando FD1" apunta a / dev / null

Entonces, todos los resultados que el "comando" escribe en su FD 2 (stderr) se dirigen a la tubería y son leídos por "grep" en el otro lado. Todos los resultados que el "comando" escribe en su FD 1 (stdout) llegan a / dev / null.

Si, en cambio, ejecuta lo siguiente:

command >/dev/null 2>&1 | grep 'something'

Esto es lo que pasa:

1. se crea una tubería y se le apunta "comando FD 1" y "grep FD 0"
2. "comando FD 1" apunta a / dev / null
3. "comando FD 2" apunta a dónde apunta FD 1 actualmente (/ dev / null)

Entonces, todos los stdout y stderr del "comando" van a / dev / null. Nada va a la tubería y, por lo tanto, "grep" se cerrará sin mostrar nada en la pantalla.

También tenga en cuenta que las redirecciones (descriptores de archivo) pueden ser de solo lectura (<), de solo escritura (>) o de lectura-escritura (<>).

Una nota final. Si un programa escribe algo en FD1 o FD2, depende completamente del programador. La buena práctica de programación dicta que los mensajes de error deben ir a FD 2 y la salida normal a FD 1, pero a menudo encontrará una programación descuidada que mezcla los dos o ignora la convención.

Si está usando Bash, entonces use:

command >/dev/null |& grep "something"

http://www.gnu.org/software/bash/manual/bashref.html#Pipelines

Para aquellos que desean redirigir stdout y stderr permanentemente a archivos, grep en stderr, pero mantén el stdout para escribir mensajes en un tty:

# save tty-stdout to fd 3
exec 3>&1
# switch stdout and stderr, grep (-v) stderr for nasty messages and append to files
exec 2> >(grep -v "nasty_msg" >> std.err) >> std.out
# goes to the std.out
echo "my first message" >&1
# goes to the std.err
echo "a error message" >&2
# goes nowhere
echo "this nasty_msg won't appear anywhere" >&2
# goes to the tty
echo "a message on the terminal" >&3

Esto redirigirá command1 stderr a command2 stdin, mientras deja command1 stdout como está.

exec 3>&1
command1 2>&1 >&3 3>&- | command2 3>&-
exec 3>&-

Tomado de LDP

Acabo de encontrar una solución para enviar stdouta un comando y stderra otro, utilizando tuberías con nombre.

Aquí va.

mkfifo stdout-target
mkfifo stderr-target
cat < stdout-target | command-for-stdout &
cat < stderr-target | command-for-stderr &
main-command 1>stdout-target 2>stderr-target

Probablemente sea una buena idea eliminar las tuberías con nombre después.

Puede usar el shell rc .

Primero instale el paquete (es menos de 1 MB).

Este un ejemplo de cómo se deseche la salida estándar y el error estándar de tubo de grep en rc:

find /proc/ >[1] /dev/null |[2] grep task

Puedes hacerlo sin salir de Bash:

rc -c 'find /proc/ >[1] /dev/null |[2] grep task'

Como habrá notado, puede especificar qué descriptor de archivo desea canalizar utilizando corchetes después de la canalización.

Los descriptores de archivo estándar están numerados como tales:

• 0: entrada estándar
• 1: salida estándar
• 2: error estándar

Trato de seguir, encuentro que funciona también,

command > /dev/null 2>&1 | grep 'something'