¿Cómo puedo enviar stdout a múltiples comandos?

Hay algunos comandos que filtran o actúan en la entrada, y luego la pasan como salida, creo que generalmente stdout, pero algunos comandos simplemente tomarán stdiny harán lo que hagan con ella, y no generarán nada.

Estoy más familiarizado con OS X, por lo que hay dos que se me ocurren de inmediato pbcopyy pbpaste, que son medios para acceder al portapapeles del sistema.

De todos modos, sé que si quiero tomar stdout y escupir la salida para ir a ambos stdouty a un archivo, entonces puedo usar el teecomando. Y sé un poco sobre eso xargs, pero no creo que eso sea lo que estoy buscando.

Quiero saber cómo puedo dividir stdoutpara ir entre dos (o más) comandos. Por ejemplo:

cat file.txt | stdout-split -c1 pbcopy -c2 grep -i errors

Probablemente haya un mejor ejemplo que ese, pero realmente estoy interesado en saber cómo puedo enviar stdout a un comando que no lo retransmite y mientras evito que stdoutsea ​​"silenciado": no estoy preguntando cómo hacer catun archivo y grepparte de él y cópielo en el portapapeles; los comandos específicos no son tan importantes.

Además, no estoy preguntando cómo enviar esto a un archivo y stdoutesta puede ser una pregunta "duplicada" (lo siento), pero busqué un poco y solo pude encontrar otras similares que preguntaban cómo dividir entre stdout y un archivo - y las respuestas a esas preguntas parecían ser tee, lo cual no creo que funcione para mí.

Finalmente, puede preguntar "¿por qué no hacer que pbcopy sea lo último en la cadena de tuberías?" y mi respuesta es 1) ¿qué pasa si quiero usarlo y aún así ver el resultado en la consola? 2) ¿Qué pasa si quiero usar dos comandos que no salen stdoutdespués de que procesan la entrada?

Ah, y una cosa más: me doy cuenta de que podría usar teeuna tubería con nombre ( mkfifo), pero esperaba que esto se pudiera hacer en línea, de manera concisa, sin una configuración previa :)

Puede usar teey procesar la sustitución para esto:

cat file.txt | tee >(pbcopy) | grep errors

Esto enviará toda la salida de cat file.txta pbcopy, y solo obtendrá el resultado grepen su consola.

Puede poner múltiples procesos en la teeparte:

cat file.txt | tee >(pbcopy) >(do_stuff) >(do_more_stuff) | grep errors

Puede especificar varios nombres de archivo teey, además, la salida estándar se puede canalizar en un comando. Para enviar la salida a múltiples comandos, debe crear varias tuberías y especificar cada una de ellas como una salida de tee. Hay varias maneras de hacer esto.

Proceso de sustitución

Si su shell es ksh93, bash o zsh, puede usar la sustitución de procesos. Esta es una manera de pasar una tubería a un comando que espera un nombre de archivo. El shell crea la tubería y pasa un nombre de archivo como /dev/fd/3al comando. El número es el descriptor de archivo al que está conectada la tubería. Algunas variantes de Unix no son compatibles /dev/fd; en estos, se usa una tubería con nombre en su lugar (ver más abajo).

tee >(command1) >(command2) | command3

Descriptores de archivo

En cualquier shell POSIX, puede usar múltiples descriptores de archivo explícitamente. Esto requiere una variante de Unix que admita /dev/fd, ya que todas menos una de las salidas de teedeben especificarse por nombre.

{ { { tee /dev/fd/3 /dev/fd/4 | command1 >&9;
    } 3>&1 | command2 >&9;
  } 4>&1 | command3 >&9;
} 9>&1

Tubos con nombre

El método más básico y portátil es utilizar tuberías con nombre . La desventaja es que necesita encontrar un directorio de escritura, crear las tuberías y limpiar después.

tmp_dir=$(mktemp -d)
mkfifo "$tmp_dir/f1" "$tmp_dir/f2"
command1 <"$tmp_dir/f1" & pid1=$!
command2 <"$tmp_dir/f2" & pid2=$!
tee "$tmp_dir/f1" "$tmp_dir/f2" | command3
rm -rf "$tmp_dir"
wait $pid1 $pid2

Solo juega con la sustitución del proceso.

mycommand_exec |tee >(grep ook > ook.txt) >(grep eek > eek.txt)

grepson dos binarios que tienen el mismo resultado mycommand_execque su entrada específica del proceso.

Si está utilizando zsh, puede aprovechar el poder de la MULTIOSfunción, es decir, deshacerse del teecomando por completo:

uname >file1 >file2

solo escribirá la salida de unamedos archivos diferentes: file1y file2, lo que es equivalente auname | tee file1 >file2

De manera similar, la redirección de entradas estándar

wc -l <file1 <file2

es equivalente a cat file1 file2 | wc -l(tenga en cuenta que esto no es lo mismo que wc -l file1 file2, el último cuenta el número de líneas en cada archivo por separado).

Por supuesto, también puede usarlo MULTIOSpara redirigir la salida, no a archivos, sino a otros procesos, mediante la sustitución de procesos, por ejemplo:

echo abc > >(grep -o a) > >(tr b x) > >(sed 's/c/y/')

Para una salida razonablemente pequeña producida por un comando, podemos redirigir la salida a un archivo temporal y enviar esos archivos temporales a los comandos en bucle. Esto puede ser útil cuando el orden de los comandos ejecutados puede ser importante.

El siguiente script, por ejemplo, podría hacer eso:

#!/bin/sh

temp=$( mktemp )
cat /dev/stdin > "$temp"

for arg
do
    eval "$arg" < "$temp"
done
rm "$temp"

Prueba de ejecución en Ubuntu 16.04 con /bin/shcomo dashshell:

$ cat /etc/passwd | ./multiple_pipes.sh  'wc -l'  'grep "root"'                                                          
48
root:x:0:0:root:/root:/bin/bash

Capture el comando STDOUTen una variable y reutilícelo tantas veces como desee:

commandoutput="$(command-to-run)"
echo "$commandoutput" | grep -i errors
echo "$commandoutput" | pbcopy

Si necesita capturar STDERRtambién, use 2>&1al final del comando, así:

commandoutput="$(command-to-run 2>&1)"

Esto puede ser útil: http://www.spinellis.gr/sw/dgsh/ (shell de gráfico dirigido) Parece un reemplazo de bash que admite una sintaxis más fácil para los comandos "multipipe".

Aquí hay una solución parcial rápida y sucia, compatible con cualquier shell incluido busybox.

El problema más estrecho que resuelve es: imprimir el completo stdouten una consola y filtrarlo en otra, sin archivos temporales ni canalizaciones con nombre.

• Inicie otra sesión en el mismo host. Para averiguar su nombre TTY, escriba tty. Vamos a suponer /dev/pty/2.
• En la primera sesión, ejecute the_program | tee /dev/pty/2 | grep ImportantLog:

Obtiene un registro completo y uno filtrado.