¿Cómo ejecuto un comando en un bucle hasta que veo alguna cadena en stdout?

Question

Estoy seguro de que hay un trazador de líneas trivial con perl, ruby, bash, cualquiera que sea que me permita ejecutar un comando en un bucle hasta que observe una cadena en stdout, luego me detengo. Idealmente, me gustaría capturar stdout también, pero si va a la consola, eso podría ser suficiente.

El entorno particular en cuestión en este momento es RedHat Linux, pero a veces también necesita lo mismo en Mac. Entonces algo, genérico y * nixy sería lo mejor. No me importa Windows, presumiblemente una cosa * nixy funcionaría bajo cygwin.

ACTUALIZACIÓN: Tenga en cuenta que por "observar una cadena" me refiero a "stdout contiene una cadena" no "stdout ES una cadena".

Answer 1

En Perl:

#!/usr/local/bin/perl -w 

if (@ARGV != 2) 
{ 
    print "Usage: watchit.pl <cmd> <str>\n"; 
    exit(1); 
} 

$cmd = $ARGV[0]; 
$str = $ARGV[1]; 

while (1) 
{ 
    my $output = `$cmd`; 
    print $output; # or dump to file if desired 
    if ($output =~ /$str/) 
    { 
     exit(0); 
    } 
} 

Ejemplo:

[bash$] ./watchit.pl ls stop 
watchit.pl 
watchit.pl~ 
watchit.pl 
watchit.pl~ 
... # from another terminal type "touch stop" 
stop 
watchit.pl 
watchit.pl~ 

Es posible que desee añadir un sueño allí, sin embargo.

Answer 2

Hay un montón de maneras de hacer esto, el primero que vino a la mente fue:

OUTPUT=""; 
while [ `echo $OUTPUT | grep -c somestring` = 0 ]; do 
    OUTPUT=`$cmd`; 
done 

Donde $ cmd es el comando a ejecutar.

Para el gusto de hacerlo, aquí es una versión de la función de golpe, por lo que se puede llamar a esto más fácilmente si es algo que está queriendo invocar desde una consola interactiva sobre una base regular:

function run_until() { 
    OUTPUT=""; 
    while [ `echo $OUTPUT | grep -c $2` = 0 ]; do 
    OUTPUT=`$1`; 
    echo $OUTPUT; 
    done 
} 

exención de responsabilidad : solo se ha probado ligeramente, puede ser necesario realizar escapes adicionales, etc. si los comandos tienen muchos argumentos o si la cadena contiene caracteres especiales.

EDITAR: Con base en la retroalimentación de comentarios de Adam - si No necesitan la salida por cualquier razón (es decir, no quieren mostrar la salida), entonces usted puede utilizar esta versión más corta, con menos uso de acentos abiertos y por lo tanto menos sobrecarga:

OUTPUT=0; 
while [ "$OUTPUT" = 0 ]; do 
    OUTPUT=`$cmd | grep -c somestring`; 
done 

BASH versión de función también:

function run_until() { 
    OUTPUT=0; 
    while [ "$OUTPUT" = 0 ]; do 
    OUTPUT=`$1 | grep -c $2`; 
    done 
} 

Answer 3

while (/bin/true); do 
    OUTPUT=`/some/command` 
    if [[ "x$OUTPUT" != "x" ]]; then 
    echo $OUTPUT 
    break 
    fi 

    sleep 1 
done 

Answer 4

EDITAR: Mi respuesta original fue asumir que "una cadena" significa "cualquier cadena". Si necesita buscar uno específico, Perl es probablemente su mejor opción, ya que casi nada puede vencer a Perl en lo que respecta a la coincidencia de REGEX.

Sin embargo, si no puede usar Perl por algún motivo (puede esperar que Perl esté presente en la mayoría de las distribuciones de Linux, pero nadie obliga al usuario a instalarlo, aunque Perl puede no estar disponible), puede hacerlo con la ayuda de grep. Sin embargo, algunas de las soluciones grep que he visto hasta ahora son subóptimas (son más lentas de lo que sería necesario). En ese caso, yo preferiría hacer lo siguiente:

MATCH=''; while [[ "e$MATCH" == "e" ]]; do MATCH=`COMMAND | grep "SOME_STRING"`; done; echo $MATCH 

Reemplazar COMANDO con el comando de hecho para correr y SOME_STRING con la cadena a buscar. Si SOME_STRING se encuentra en la salida de COMMAND, el ciclo se detendrá e imprimirá el resultado donde se encontró SOME_STRING.

respuesta original:

Probablemente no

la mejor solución (no soy un buen programador bash), pero funcionará :-P

RUN=''; while [[ "e$RUN" == "e" ]]; do RUN=`XXXX`; done ; echo $RUN 

basta con sustituir XXXX con su llamada de comando, por ejemplo, intente utilizar "echo" y nunca volverá (ya que el eco nunca imprime nada en stdout); sin embargo, si usa "echo test" terminará de inmediato y finalmente imprimirá la prueba.

Answer 5

CONT=1; while [ $CONT -gt 0 ]; do $CMD | tee -a $FILE | grep -q $REGEXP; CONT=$? ; done 

El comando tee puede capturar la salida estándar en un tubo mientras que todavía pasar los datos en, y -a hace añadir al archivo en lugar de sobrescribir cada vez. grep -qreturn 0 si hubiera una coincidencia, 1 de lo contrario y no escribe nada en stdout. $? es el valor de retorno del comando anterior, por lo que $CONT será el valor de retorno de grep en este caso.

Answer 6

Una forma sencilla de hacer esto sería

until `/some/command` 
do 
    sleep 1 
done 

Los acentos abiertos todo el comando de hacer la prueba until por alguna salida que se devuelve en lugar de probar el valor de salida del comando.

Answer 7

grep -c 99999 imprimirá 99999 líneas de contexto para el partido (supongo que esto será suficiente):

while true; do /some/command | grep expected -C 99999 && break; done 

o

until /some/command | grep expected -C 9999; do echo -n .; done 

... esto va a imprimir algunos puntos agradables para indicar el progreso .

Answer 8

Me sorprende que no he visto una breve Perl de una sola línea se ha mencionado aquí:

perl -e 'do { sleep(1); $_ = `command`; print $_; } until (m/search/);' 

Perl es un lenguaje muy agradable para cosas como esta. Reemplace "comando" con el comando que desea ejecutar repetidamente. Reemplaza "buscar" con lo que deseas buscar. Si desea buscar algo con una barra, reemplace m/search/ con m#search cadena con /es#.

Además, Perl se ejecuta en muchas plataformas diferentes, incluyendo Win32, y esto funcionará donde sea que tenga una instalación de Perl. Solo cambia tu comando apropiadamente.