Comment grep stream standard error (stderr)?

J'utilise ffmpeg pour obtenir les méta-informations d'un clip audio. Mais je suis incapable de le savoir.

    $ ffmpeg -i 01-Daemon.mp3  |grep -i Duration
    FFmpeg version SVN-r15261, Copyright (c) 2000-2008 Fabrice Bellard, et al.
      configuration: --prefix=/usr --bindir=/usr/bin 
      --datadir=/usr/share/ffmpeg --incdir=/usr/include/ffmpeg --libdir=/usr/lib
      --mandir=/usr/share/man --arch=i386 --extra-cflags=-O2 
      ...

J'ai vérifié, cette sortie de ffmpeg est dirigée vers stderr.

$ ffmpeg -i 01-Daemon.mp3 2> /dev/null

Donc, je pense que grep est incapable de lire le flux d'erreur pour intercepter les lignes correspondantes. Comment pouvons-nous activer grep pour lire le flux d'erreur?

En utilisant le lien nixCraft , j'ai redirigé le flux d'erreur standard vers le flux de sortie standard, puis grep a fonctionné.

$ ffmpeg -i 01-Daemon.mp3 2>&1 | grep -i Duration
  Duration: 01:15:12.33, start: 0.000000, bitrate: 64 kb/s

Mais que se passe-t-il si nous ne voulons pas rediriger stderr vers stdout?

Si vous utilisez, bashpourquoi ne pas utiliser des pipes anonymes, en résumé, ce que phunehehe a dit:

ffmpeg -i 01-Daemon.mp3 2> >(grep -i Duration)

Aucun des shells habituels (même zsh) n'autorise les pipes autres que de stdout à stdin. Mais tous les shells de style Bourne prennent en charge la réaffectation de descripteur de fichier (comme dans 1>&2). Vous pouvez donc temporairement renvoyer stdout sur fd 3 et stderr sur stdout, puis remettre fd 3 sur stdout. Si stuffproduit une sortie sur stdout et une sortie sur stderr, et que vous souhaitez appliquer filtersur la sortie d'erreur sans modifier la sortie standard, vous pouvez l'utiliser { stuff 2>&1 1>&3 | filter 1>&2; } 3>&1.

$ stuff () {
  echo standard output
  echo more output
  echo standard error 1>&2
  echo more error 1>&2
}
$ filter () {
  grep a
}
$ { stuff 2>&1 1>&3 | filter 1>&2; } 3>&1
standard output
more output
standard error

Ceci est similaire à "l'astuce de fichier temp" de phunehehe, mais utilise plutôt un canal nommé, ce qui vous permet d'obtenir des résultats un peu plus proches du moment de leur sortie, ce qui peut être pratique pour les commandes de longue durée:

$ mkfifo mypipe
$ command 2> mypipe | grep "pattern" mypipe

Dans cette construction, stderr sera dirigé vers le tuyau nommé "mypipe". Comme il grepa été appelé avec un argument de fichier, STDIN ne sera pas saisi. Malheureusement, vous devrez toujours nettoyer le tuyau nommé une fois que vous aurez terminé.

Si vous utilisez Bash 4, il existe une syntaxe de raccourci pour command1 2>&1 | command2, qui est command1 |& command2. Cependant, je pense que ceci est purement un raccourci de syntaxe, vous redirigez toujours STDERR vers STDOUT.

Les réponses de Gilles et Stefan Lasiewski sont bonnes, mais cette méthode est plus simple:

ffmpeg -i 01-Daemon.mp3 2>&1 >/dev/null | grep "pattern"

Je suppose que vous ne voulez pas que ffmpeg'sstdout soit imprimé.

Comment ça fonctionne:

• tuyaux d'abord
  • ffmpeg et grep sont lancés, avec le stdout de ffmpeg allant sur le stdin de grep
• redirections ensuite, de gauche à droite
  • Le paramètre stderr de ffmpeg est défini quelle que soit sa stdout (actuellement le canal)
  • La sortie standard de ffmpeg est définie sur / dev / null

Voir ci-dessous pour le script utilisé dans ces tests.

Grep ne peut fonctionner que sur stdin, vous devez donc convertir le flux stderr sous une forme que Grep peut analyser.

Normalement, stdout et stderr sont tous deux imprimés sur votre écran:

$ ./stdout-stderr.sh
./stdout-stderr.sh: Printing to stdout
./stdout-stderr.sh: Printing to stderr

Pour masquer stdout, mais toujours imprimer stderr, procédez comme suit:

$ ./stdout-stderr.sh >/dev/null
./stdout-stderr.sh: Printing to stderr

Mais grep ne fonctionnera pas sur stderr! Vous pouvez vous attendre à ce que la commande suivante supprime les lignes contenant «err», mais ce n'est pas le cas.

$ ./stdout-stderr.sh >/dev/null |grep --invert-match err
./stdout-stderr.sh: Printing to stderr

Voici la solution.

La syntaxe Bash suivante cachera la sortie sur stdout, mais affichera toujours stderr. Nous lançons d’abord stdout dans / dev / null, puis nous convertissons stderr en stdout, car les pipes Unix ne fonctionneront que sur stdout. Vous pouvez toujours grep le texte.

$ ./stdout-stderr.sh 2>&1 >/dev/null | grep err
./stdout-stderr.sh: Printing to stderr

(Notez que la commande ci-dessus est différente alors ./command >/dev/null 2>&1, ce qui est une commande très courante).

Voici le script utilisé pour les tests. Ceci affiche une ligne sur stdout et une ligne sur stderr:

#!/bin/sh

# Print a message to stdout
echo "$0: Printing to stdout"
# Print a message to stderr
echo "$0: Printing to stderr" >&2

exit 0

Lorsque vous dirigez la sortie d'une commande vers une autre (en utilisant |), vous ne faites que rediriger la sortie standard. Cela devrait donc expliquer pourquoi

ffmpeg -i 01-Daemon.mp3 | grep -i Duration

ne sort pas ce que vous vouliez (ça marche quand même).

Si vous ne souhaitez pas rediriger la sortie d'erreur vers la sortie standard, vous pouvez rediriger la sortie d'erreur vers un fichier, puis corrigez-la ultérieurement.

ffmpeg -i 01-Daemon.mp3 2> /tmp/ffmpeg-error
grep -i Duration /tmp/ffmpeg-error

Vous pouvez échanger les flux. Cela vous permettrait d' grepaccéder au flux d'erreur standard d'origine tout en obtenant la sortie qui était à l'origine en sortie standard dans le terminal:

somecommand 3>&2 2>&1 1>&3- | grep 'pattern'

Cela fonctionne en créant tout d'abord un nouveau descripteur de fichier (3) ouvert pour la sortie et en le configurant sur le flux d'erreur standard ( 3>&2). Ensuite, nous redirigeons l'erreur type vers la sortie standard ( 2>&1). Enfin, la sortie standard est redirigée vers l'erreur standard d'origine et le nouveau descripteur de fichier est fermé ( 1>&3-).

Dans ton cas:

ffmpeg -i 01-Daemon.mp3 3>&2 2>&1 1>&3- | grep -i Duration

Le tester:

$ ( echo "error" >&2; echo "output" ) 3>&2 2>&1 1>&3- | grep "error"
output
error

$ ( echo "error" >&2; echo "output" ) 3>&2 2>&1 1>&3- | grep -v "error"
output

J'aime utiliser la rccoquille dans ce cas.

Installez d'abord le paquet (moins de 1 Mo).

Voici un exemple de la façon dont vous écarteriez stdoutet dirigeriez stderrvers grep dans rc:

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

Vous pouvez le faire sans quitter Bash:

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

Comme vous l'avez peut-être remarqué, la syntaxe est simple, ce qui en fait la solution que je préfère.

Vous pouvez spécifier le descripteur de fichier que vous souhaitez transférer entre crochets, juste après le caractère de canal.

Les descripteurs de fichier standard sont numérotés comme tels:

• 0: entrée standard
• 1: Ouptut standard
• 2: erreur type

Une variante de l'exemple de sous-processus bash:

faire écho deux lignes à stderr et tee stderr à un fichier, grepez le tee et redirigez-vous vers stdout

(>&2 echo -e 'asdf\nfff\n') 2> >(tee some.load.errors | grep 'fff' >&1)

stdout:

fff

des.erreurs (par exemple, stderr):

asdf
fff

essayez cette commande

• créer un fichier avec un nom aléatoire
• envoyer la sortie au fichier
• envoyer le contenu du fichier à pipe
• grep

ceva -> juste un nom de variable (anglais = quelque chose)

ceva=$RANDOM$RANDOM$RANDOM; ffmpeg -i qwerty_112_0_0_record.flv 2>$ceva; cat $ceva | grep Duration; rm $ceva;