Comment puis-je diriger stderr, et non stdout?

J'ai un programme qui écrit des informations dans stdoutet stderr, et je dois passer au greptravers de ce qui arrive à stderr , sans tenir compte de stdout .

Je peux bien sûr le faire en 2 étapes:

command > /dev/null 2> temp.file
grep 'something' temp.file

mais je préférerais pouvoir le faire sans fichiers temporaires. Existe-t-il des astuces de tuyauterie intelligentes?

Redirigez d'abord stderr vers stdout - le tuyau; puis redirigez stdout vers /dev/null(sans changer où va stderr):

command 2>&1 >/dev/null | grep 'something'

Pour les détails de la redirection d'E / S dans toute sa variété, voir le chapitre sur les redirections dans le manuel de référence de Bash.

Notez que la séquence de redirections d'E / S est interprétée de gauche à droite, mais les canaux sont configurés avant l'interprétation des redirections d'E / S. Les descripteurs de fichiers tels que 1 et 2 sont des références à des descriptions de fichiers ouverts. L'opération 2>&1fait que le descripteur de fichier 2 aka stderr fait référence à la même description de fichier ouverte que le descripteur de fichier 1 aka stdout fait actuellement référence (voir dup2()et open()). L'opération >/dev/nullmodifie ensuite le descripteur de fichier 1 pour qu'il fasse référence à une description de fichier ouvert pour /dev/null, mais cela ne change pas le fait que le descripteur de fichier 2 se réfère à la description de fichier ouvert vers laquelle le descripteur de fichier 1 pointait à l'origine - à savoir, le canal.

Ou pour permuter la sortie de l'erreur standard et de la sortie standard, utilisez:

command 3>&1 1>&2 2>&3

Cela crée un nouveau descripteur de fichier (3) et l'affecte au même endroit que 1 (sortie standard), puis attribue fd 1 (sortie standard) au même endroit que fd 2 (erreur standard) et affecte finalement fd 2 (erreur standard ) au même endroit que fd 3 (sortie standard).

L'erreur standard est désormais disponible en sortie standard et l'ancienne sortie standard est conservée dans l'erreur standard. Cela peut être exagéré, mais cela donne, espérons-le, plus de détails sur les descripteurs de fichiers Bash (neuf sont disponibles pour chaque processus).

Dans Bash, vous pouvez également rediriger vers un sous-shell en utilisant la substitution de processus :

command > >(stdlog pipe)  2> >(stderr pipe)

Pour le cas en question:

command 2> >(grep 'something') >/dev/null

En combinant la meilleure de ces réponses, si vous le faites:

command 2> >(grep -v something 1>&2)

... alors tout stdout est préservé comme stdout et tout stderr est préservé comme stderr, mais vous ne verrez aucune ligne dans stderr contenant la chaîne "quelque chose".

Cela a l'avantage unique de ne pas inverser ou supprimer stdout et stderr, ni de les mélanger ensemble, ni d'utiliser de fichiers temporaires.

Il est beaucoup plus facile de visualiser les choses si vous pensez à ce qui se passe réellement avec les "redirections" et les "tuyaux". Les redirections et les canaux dans bash font une chose: modifier où les descripteurs de fichiers de processus 0, 1 et 2 pointent (voir / proc / [pid] / fd / *).

Quand une pipe ou "|" est présent sur la ligne de commande, la première chose à faire est que bash crée un fifo et pointe le FD 1 de la commande de gauche sur ce fifo, et pointe le FD 0 de la commande de droite sur le même fifo.

Ensuite, les opérateurs de redirection pour chaque côté sont évalués de gauche à droite et les paramètres actuels sont utilisés chaque fois que la duplication du descripteur se produit. Ceci est important car depuis que le tuyau a été installé en premier, le FD1 (côté gauche) et FD0 (côté droit) sont déjà modifiés par rapport à ce qu'ils auraient pu être normalement, et toute duplication de ceux-ci reflétera ce fait.

Par conséquent, lorsque vous tapez quelque chose comme ceci:

command 2>&1 >/dev/null | grep 'something'

Voici ce qui se passe, dans l'ordre:

1. un tuyau (fifo) est créé. "commande FD1" pointe vers ce tuyau. "grep FD0" est également pointé vers ce tuyau
2. "commande FD2" pointe vers l'endroit où "commande FD1" pointe actuellement (le tuyau)
3. "commande FD1" pointe vers / dev / null

Ainsi, toutes les sorties que "command" écrit sur son FD 2 (stderr) se dirigent vers le tuyau et sont lues par "grep" de l'autre côté. Toutes les sorties que la "commande" écrit dans son FD 1 (stdout) se dirigent vers / dev / null.

Si à la place, vous exécutez ce qui suit:

command >/dev/null 2>&1 | grep 'something'

Voici ce qui se passe:

1. un tuyau est créé et "commande FD 1" et "grep FD 0" sont pointés vers lui
2. "commande FD 1" pointe vers / dev / null
3. "commande FD 2" pointe vers où FD 1 pointe actuellement (/ dev / null)

Ainsi, tous les stdout et stderr de la "commande" vont dans / dev / null. Rien ne va dans le tuyau, et donc "grep" se fermera sans afficher quoi que ce soit à l'écran.

Notez également que les redirections (descripteurs de fichiers) peuvent être en lecture seule (<), en écriture seule (>) ou en lecture-écriture (<>).

Une note finale. Qu'un programme écrive quelque chose sur FD1 ou FD2, cela dépend entièrement du programmeur. Les bonnes pratiques de programmation dictent que les messages d'erreur doivent aller à FD 2 et la sortie normale à FD 1, mais vous trouverez souvent une programmation bâclée qui mélange les deux ou ignore la convention.

Si vous utilisez Bash, utilisez:

command >/dev/null |& grep "something"

http://www.gnu.org/software/bash/manual/bashref.html#Pipelines

Pour ceux qui veulent rediriger stdout et stderr en permanence vers des fichiers, grep sur stderr, mais gardez la stdout pour écrire des messages sur un tty:

# save tty-stdout to fd 3
exec 3>&1
# switch stdout and stderr, grep (-v) stderr for nasty messages and append to files
exec 2> >(grep -v "nasty_msg" >> std.err) >> std.out
# goes to the std.out
echo "my first message" >&1
# goes to the std.err
echo "a error message" >&2
# goes nowhere
echo "this nasty_msg won't appear anywhere" >&2
# goes to the tty
echo "a message on the terminal" >&3

Cela redirigera command1 stderr vers command2 stdin, tout en laissant command1 stdout tel quel.

exec 3>&1
command1 2>&1 >&3 3>&- | command2 3>&-
exec 3>&-

Extrait du LDP

Je viens de trouver une solution pour envoyer stdoutà une commande et stderrà une autre, en utilisant des canaux nommés.

Voici.

mkfifo stdout-target
mkfifo stderr-target
cat < stdout-target | command-for-stdout &
cat < stderr-target | command-for-stderr &
main-command 1>stdout-target 2>stderr-target

C'est probablement une bonne idée de supprimer les tuyaux nommés par la suite.

Vous pouvez utiliser le shell rc .

Installez d'abord le package (c'est moins de 1 Mo).

Voici un exemple de la façon dont vous pouvez ignorer la sortie standard et l'erreur standard de canal vers 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é, vous pouvez spécifier le descripteur de fichier que vous souhaitez canaliser en utilisant des crochets après le tube.

Les descripteurs de fichiers standard sont numérotés comme suit:

• 0: entrée standard
• 1: sortie standard
• 2: erreur standard

J'essaie de suivre, je trouve que ça marche aussi,

command > /dev/null 2>&1 | grep 'something'