Comment exécuter une commande dans une boucle jusqu'à ce que je vois une chaîne dans stdout?

Je suis sûr qu'il ya quelques trivial one-liner avec perl, ruby, bash, peu importe ce que cela permettez-moi de lancer une commande dans une boucle jusqu'à ce que j'observe une chaîne de caractères dans la sortie standard, puis de s'arrêter. Idéalement, j'aimerais capturer la sortie standard, mais si c'est pour de la console, cela peut être suffisant.

L'environnement particulier dans la question du moment, c'est RedHat Linux, mais ont besoin de la même chose sur Mac, parfois trop. Donc, quelque chose, générique et *nixy serait le mieux. Ne se soucient pas de Windows - sans doute un *nixy chose serait de travailler sous cygwin.

Mise à JOUR: Remarque: les "observer une chaîne de caractères" je veux dire "stdout contient une chaîne de caractères" non "stdout EST une chaîne de caractères".

source d'informationauteur Alex Miller

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);
    }
}

Exemple:

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

Vous voudrez peut-être ajouter un sommeil de là, si.

10

Il y a un tas de façons de le faire, la première qui vient à l'esprit:
```
OUTPUT=""; 
while [ `echo $OUTPUT | grep -c somestring` = 0 ]; do 
  OUTPUT=`$cmd`; 
done
```
Où $cmd est votre commande à exécuter.

Pour le fun, voici un BASH fonction de la version, vous pouvez donc appeler cela plus facilement si c'est quelque chose que vous êtes désireux pour appeler à partir d'un shell interactif sur une base régulière:
```
function run_until () {
  OUTPUT="";
  while [ `echo $OUTPUT | grep -c $2` = 0 ]; do
    OUTPUT=`$1`;
    echo $OUTPUT;
  done
}
```
Avertissement: peu testé, peut-être besoin de faire un peu plus d'échapper etc. si votre commande a beaucoup d'arguments pour la chaîne contient des caractères spéciaux.

MODIFIER: sur la Base des commentaires à partir d'Adam commentaire - si vous ne pas besoin de la sortie pour une raison quelconque (c'est à dire ne voulez pas afficher le résultat), alors vous pouvez utiliser cette version plus courte, avec moins d'utilisation de backticks et donc moins de frais généraux:
```
OUTPUT=0; 
while [ "$OUTPUT" = 0 ]; do 
  OUTPUT=`$cmd | grep -c somestring`;
done
```
BASH fonction de la version aussi:
```
function run_until () {
  OUTPUT=0; 
  while [ "$OUTPUT" = 0 ]; do 
    OUTPUT=`$1 | grep -c $2`; 
  done
}
```
7

Je suis surpris, je n'ai pas vu une brève Perl one-liner mentionné ici:
```
perl -e 'do { sleep(1); $_ = `command`; print $_; } until (m/search/);'
```
Perl est vraiment une belle langue pour des trucs comme ça. Remplacer "commande" avec la commande que vous souhaitez exécuter plusieurs fois. Remplacer "recherche" avec ce que vous voulez rechercher. Si vous recherchez quelque chose avec une barre oblique, puis remettez m/search/ avec m#search chaîne avec /es#.

Aussi, Perl fonctionne sur beaucoup de plates-formes différentes, y compris Win32, et que cela fonctionne partout où vous avez une installation Perl. Il suffit de changer votre commande de façon appropriée.
4

grep -c 99999 imprime 99999 lignes de contexte pour le match (je suppose que ce sera suffisant):
```
while true; do /some/command | grep expected -C 99999 && break; done
```
ou
```
until /some/command | grep expected -C 9999; do echo -n .; done
```
...cela permettra d'imprimer quelques bons points pour indiquer la progression.

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

  sleep 1
done

1

EDIT:
Ma réponse originale à cette question a été en supposant que "une chaîne de caractères" signifie "toute chaîne de caractère". Si vous avez besoin de regarder pour un spécifique, Perl est probablement votre meilleure option, car presque rien ne peut battre Perl quand il s'agit de l'expression rationnelle correspondant.

Toutefois, si vous ne pouvez pas utiliser Perl pour une raison quelconque (vous pouvez vous attendre à Perl d'être présent dans la plupart des distributions Linux, mais personne n'oblige l'utilisateur à l'installer, bien que Perl peut ne pas être disponible), vous pouvez le faire avec l'aide de grep. Cependant, certains de la commande grep solutions que j'ai vu jusqu'à présent ne sont pas optimales (ils sont plus lentes que celles qui seraient nécessaires). Dans ce cas, je préfère faire les suivants:
```
MATCH=''; while [[ "e$MATCH" == "e" ]]; do MATCH=`COMMAND | grep "SOME_STRING"`; done; echo $MATCH
```
Remplacer COMMANDE avec la commande à exécuter et CHAÎNE_QUELCONQUE avec la chaîne de caractères à rechercher. Si CHAÎNE_QUELCONQUE est trouvé dans la sortie de COMMANDE, la boucle s'arrête et imprimer la sortie où CHAÎNE_QUELCONQUE a été trouvé.

RÉPONSE ORIGINALE À CETTE QUESTION:

Probablement pas la meilleure solution (je ne suis pas bon bash programmeur), mais ça marche 😛
```
RUN=''; while [[ "e$RUN" == "e" ]]; do RUN=`XXXX`; done ; echo $RUN
```
Il suffit de remplacer XXXX par votre appel à la commande, par exemple, essayez d'utiliser "echo" et il ne reviendra jamais (comme echo jamais imprime rien à stdout), toutefois, si vous utilisez "echo test" il va mettre fin à la fois, et enfin d'imprimer test.
1
```
CONT=1; while [ $CONT -gt 0 ]; do $CMD | tee -a $FILE | grep -q $REGEXP; CONT=$? ; done
```
La commande tee pouvez capturer la sortie standard dans un tuyau tout en encore de transmettre les données sur, et -a fait ajouter dans le fichier au lieu de l'écraser à chaque fois. grep -q sera return 0 si il y avait un match, 1 autrement et de ne rien écrire sur la sortie standard stdout. $? est la valeur de retour de la commande précédente, de sorte $CONT sera la valeur de retour de grep dans ce cas.
0

Une façon simple de le faire ce serait
```
until `/some/command`
do
  sleep 1
done
```
Les backticks autour de la commande de rendre les until de test pour certains sortie pour être retourné plutôt que de tester la valeur de sortie de la commande.

Vous devez vous connecter pour publier un commentaire.