Canalizar a múltiples archivos en el shell

Tengo una aplicación que producirá una gran cantidad de datos que no deseo almacenar en el disco. La aplicación genera principalmente datos que no deseo utilizar, pero un conjunto de información útil que debe dividirse en archivos separados. Por ejemplo, dada la siguiente salida:

JUNK
JUNK
JUNK
JUNK
A 1
JUNK
B 5
C 1
JUNK

Podría ejecutar la aplicación tres veces así:

./app | grep A > A.out
./app | grep B > B.out
./app | grep C > C.out

Esto me daría lo que quiero, pero tomaría demasiado tiempo. Tampoco quiero volcar todas las salidas en un solo archivo y analizarlo.

¿Hay alguna forma de combinar las tres operaciones que se muestran arriba de tal manera que solo necesito ejecutar la aplicación una vez y aún obtener tres archivos de salida separados?

Si tienes tee

./app | tee >(grep A > A.out) >(grep B > B.out) >(grep C > C.out) > /dev/null

(desde aquí )

( acerca de la sustitución del proceso )

Puedes usar awk

./app | awk '/A/{ print > "A.out"}; /B/{ print > "B.out"}; /C/{ print > "C.out"}'

También puedes usar las habilidades de combinación de patrones de tu caparazón :

./app | while read line; do 
     [[ "$line" =~ A ]] && echo $line >> A.out; 
     [[ "$line" =~ B ]] && echo $line >> B.out; 
     [[ "$line" =~ C ]] && echo $line >> C.out; 
 done

O incluso:

./app | while read line; do for foo in A B C; do 
     [[ "$line" =~ "$foo" ]] && echo $line >> "$foo".out; 
  done; done

Una forma más segura de lidiar con barras invertidas y líneas que comienzan con -:

./app | while IFS= read -r line; do for foo in A B C; do 
     [[ "$line" =~ "$foo" ]] && printf -- "$line\n" >> "$foo".out; 
  done; done

Como @StephaneChazelas señala en los comentarios, esto no es muy eficiente. La mejor solución es probablemente @ AurélienOoms ' .

Si tiene varios núcleos y desea que los procesos estén en paralelo, puede hacer lo siguiente:

parallel -j 3 -- './app | grep A > A.out' './app | grep B > B.out' './app | grep C > C.out'

Esto generará tres procesos en núcleos paralelos. Si desea que haya algún resultado en la consola o un archivo maestro, tiene la ventaja de mantener el resultado en algún orden, en lugar de mezclarlo.

La utilidad gnu paralela de Ole Tange puede obtenerse de la mayoría de los repositorios bajo el nombre paralelo o moreutils . La fuente se puede obtener de Savannah.gnu.org . También hay un video instructivo introductorio aquí .

Apéndice

Usando la versión más reciente de paralelo (no necesariamente la versión en su repositorio de distribución), puede usar la construcción más elegante:

./app | parallel -j3 -k --pipe 'grep {1} >> {1}.log' ::: 'A' 'B' 'C'

Lo que logra el resultado de ejecutar uno ./app y 3 procesos grep paralelos en núcleos o subprocesos separados (según lo determinado por el mismo paralelo, también considere que -j3 es opcional, pero se proporciona en este ejemplo con fines instructivos).

La versión más nueva de paralelo se puede obtener haciendo:

wget http://ftpmirror.gnu.org/parallel/parallel-20131022.tar.bz2

Luego, el desempaquetado habitual, cd to parallel- {date}, ./configure && make, sudo make install. Esto instalará paralelo, página de manual paralela y página de manual paralelo_tutorial.

Aquí hay uno en Perl:

./app | perl -ne 'BEGIN {open(FDA, ">A.out") and 
                         open(FDB, ">B.out") and 
                         open(FDC, ">C.out") or die("Cannot open files: $!\n")} 
                  print FDA $_ if /A/; print FDB $_ if /B/; print FDC $_ if /C/'

sed -ne/A/w\ A.out -e/B/w\ B.out -e/C/p <in >C.out

... si <ines legible, los tres archivos se truncarán antes de que se les escriba algo.