Come posso pipe stderr e non stdout?

Ho un programma che scrive informazioni su stdoute stderr, e ho bisogno di greppassare attraverso ciò che sta arrivando a stderr , ignorando stdout .

Ovviamente posso farlo in 2 passaggi:

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

ma preferirei essere in grado di farlo senza i file temporanei. Ci sono trucchi intelligenti per le tubazioni?

Per prima cosa reindirizza stderr a stdout: la pipe; quindi reindirizzare stdout a /dev/null(senza cambiare la direzione di stderr):

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

Per i dettagli sul reindirizzamento I / O in tutta la sua varietà, consultare il capitolo Reindirizzamenti nel manuale di riferimento di Bash.

Si noti che la sequenza dei reindirizzamenti I / O viene interpretata da sinistra a destra, ma i tubi vengono impostati prima dell'interpretazione dei reindirizzamenti I / O. I descrittori di file come 1 e 2 sono riferimenti a descrizioni di file aperti. L'operazione 2>&1fa in modo che il descrittore di file 2 aka stderr si riferisca alla stessa descrizione di file aperta di cui al descrittore di file 1 aka stdout si riferisce attualmente (vedere dup2()e open()). L'operazione >/dev/nullquindi modifica il descrittore di file 1 in modo che faccia riferimento a una descrizione di file aperta /dev/null, ma ciò non cambia il fatto che il descrittore di file 2 si riferisce alla descrizione di file aperta a cui il descrittore di file 1 originariamente puntava, vale a dire la pipe.

In alternativa, per scambiare l'output da errore standard e output standard, utilizzare:

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

Questo crea un nuovo descrittore di file (3) e lo assegna nella stessa posizione di 1 (output standard), quindi assegna fd 1 (output standard) nella stessa posizione di fd 2 (errore standard) e infine assegna fd 2 (errore standard ) nello stesso posto di fd 3 (output standard).

L'errore standard è ora disponibile come output standard e il vecchio output standard viene conservato nell'errore standard. Questo può essere eccessivo, ma si spera che fornisca maggiori dettagli sui descrittori di file Bash (ce ne sono nove disponibili per ogni processo).

In Bash, puoi anche reindirizzare a una subshell usando la sostituzione del processo :

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

Per il caso in questione:

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

Combinando la migliore di queste risposte, se lo fai:

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

... quindi tutto lo stdout viene conservato come stdout e tutto lo stderr viene conservato come stderr, ma non vedrai alcuna riga in stderr contenente la stringa "qualcosa".

Questo ha il vantaggio unico di non invertire o scartare stdout e stderr, né di metterli insieme o di usare file temporanei.

È molto più facile visualizzare le cose se pensi a cosa sta realmente succedendo con "reindirizzamenti" e "pipe". I reindirizzamenti e le pipe in bash fanno una cosa: modifica dove i descrittori del file di processo 0, 1 e 2 puntano a (vedi / proc / [pid] / fd / *).

Quando una pipe o "|" l'operatore è presente sulla riga di comando, la prima cosa che succede è che bash crea un FIFO e punta il FD 1 del comando sul lato sinistro verso questo FIFO, e punta FD 0 del comando sul lato destro sullo stesso FIFO.

Successivamente, gli operatori di reindirizzamento per ciascun lato vengono valutati da sinistra a destra e vengono utilizzate le impostazioni correnti ogni volta che si verifica la duplicazione del descrittore. Questo è importante perché dalla prima installazione del tubo, l'FD1 (lato sinistro) e l'FD0 (lato destro) sono già cambiati da quello che avrebbero potuto essere normalmente, e qualsiasi duplicazione di questi rifletterà quel fatto.

Pertanto, quando si digita qualcosa di simile al seguente:

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

Ecco cosa succede, in ordine:

1. viene creato un pipe (fifo). "comando FD1" è puntato su questa pipe. Anche "grep FD0" è puntato su questa pipe
2. "comando FD2" è indicato dove "comando FD1" indica attualmente (la pipe)
3. "comando FD1" è puntato su / dev / null

Quindi, tutto l'output che "command" scrive su FD 2 (stderr) si dirige verso la pipe e viene letto da "grep" dall'altra parte. Tutto l'output che "comando" scrive nel suo FD 1 (stdout) si dirige verso / dev / null.

Se invece, esegui quanto segue:

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

Ecco cosa succede:

1. viene creato un pipe e "command FD 1" e "grep FD 0" vengono puntati su di esso
2. "comando FD 1" è puntato su / dev / null
3. "comando FD 2" è indicato dove attualmente punta FD 1 (/ dev / null)

Quindi, tutto stdout e stderr dal "comando" vanno a / dev / null. Nulla va alla pipa, e quindi "grep" si chiuderà senza visualizzare nulla sullo schermo.

Si noti inoltre che i reindirizzamenti (descrittori di file) possono essere di sola lettura (<), sola scrittura (>) o lettura-scrittura (<>).

Un'ultima nota. Se un programma scrive qualcosa su FD1 o FD2, dipende interamente dal programmatore. La buona pratica di programmazione impone che i messaggi di errore debbano andare a FD 2 e l'output normale a FD 1, ma spesso troverete una programmazione sciatta che mescola i due o ignora in altro modo la convenzione.

Se stai usando Bash, usa:

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

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

Per coloro che vogliono reindirizzare permanentemente stdout e stderr su file, grep su stderr, ma mantenere lo stdout per scrivere messaggi su 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

Questo reindirizzerà command1 stderr a command2 stdin, lasciando command1 stdout così com'è.

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

Tratto da LDP

Ho appena trovato una soluzione per l'invio stdouta un comando e stderrad un altro, usando named pipe.

Ecco qui.

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

È probabilmente una buona idea rimuovere le pipe nominate in seguito.

Puoi usare la shell rc .

Innanzitutto installa il pacchetto (è inferiore a 1 MB).

Questo è un esempio di come scartare l'output standard e l'errore pipe standard per grep in rc:

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

Puoi farlo senza lasciare Bash:

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

Come avrai notato, puoi specificare il descrittore di file che vuoi reindirizzare usando le parentesi dopo la pipe.

I descrittori di file standard sono numerati come tali:

• 0: input standard
• 1: uscita standard
• 2: errore standard

Provo a seguire, trovo che funzioni anche,

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