Como posso canalizar stderr, e não stdout?

Eu tenho um programa que grava informações no stdoute stderr, e preciso passar greppelo que está chegando ao stderr , apesar de desconsiderar o stdout .

Claro que posso fazê-lo em 2 etapas:

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

mas eu preferiria poder fazer isso sem arquivos temporários. Existem truques inteligentes de tubulação?

Primeiro redirecione o stderr para o stdout - o pipe; em seguida, redirecione o stdout para /dev/null(sem alterar para onde o stderr está indo):

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

Para obter detalhes sobre o redirecionamento de E / S em toda a sua variedade, consulte o capítulo Redirecionamentos no manual de referência do Bash.

Observe que a sequência de redirecionamentos de E / S é interpretada da esquerda para a direita, mas os pipes são configurados antes que os redirecionamentos de E / S sejam interpretados. Descritores de arquivo como 1 e 2 são referências para abrir descrições de arquivo. A operação 2>&1faz com que o descritor de arquivo 2 aka stderr se refira à mesma descrição de arquivo aberto que o descritor de arquivo 1 aka stdout se refere atualmente (consulte dup2()e open()). A operação >/dev/nullaltera o descritor de arquivo 1 para que ele se refira a uma descrição de arquivo aberto /dev/null, mas isso não altera o fato de que o descritor de arquivo 2 se refere à descrição do arquivo aberto que o descritor de arquivo 1 estava apontando originalmente - a saber, o canal.

Ou, para trocar a saída do erro padrão e da saída padrão, use:

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

Isso cria um novo descritor de arquivo (3) e o atribui ao mesmo local que 1 (saída padrão), depois atribui o fd 1 (saída padrão) ao mesmo local que o fd 2 (erro padrão) e, finalmente, atribui o fd 2 (erro padrão) ) para o mesmo local que fd 3 (saída padrão).

O erro padrão agora está disponível como saída padrão e a saída padrão antiga é preservada no erro padrão. Isso pode ser um exagero, mas espero que dê mais detalhes sobre os descritores de arquivos Bash (há nove disponíveis para cada processo).

No Bash, você também pode redirecionar para um subshell usando a substituição de processo :

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

Para o caso em questão:

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

Combinando as melhores respostas, se você:

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

... todo stdout é preservado como stdout e todo stderr é preservado como stderr, mas você não verá nenhuma linha no stderr que contenha a string "something".

Isso tem a vantagem exclusiva de não reverter ou descartar stdout e stderr, nem esmagá-los juntos, nem usar arquivos temporários.

É muito mais fácil visualizar as coisas se você pensar sobre o que realmente está acontecendo com "redirecionamentos" e "pipes". Redirecionamentos e canais no bash fazem uma coisa: modifique para onde os descritores de arquivo de processo 0, 1 e 2 apontam para (consulte / proc / [pid] / fd / *).

Quando um tubo ou "|" Se o operador estiver presente na linha de comando, a primeira coisa a acontecer é que o bash cria um fifo e aponta o FD 1 do comando do lado esquerdo para este fifo e aponta o FD 0 do comando do lado direito para o mesmo fifo.

Em seguida, os operadores de redirecionamento de cada lado são avaliados da esquerda para a direita e as configurações atuais são usadas sempre que ocorre a duplicação do descritor. Isso é importante porque, desde que o tubo foi configurado primeiro, o FD1 (lado esquerdo) e o FD0 (lado direito) já foram alterados do que normalmente poderiam ter sido, e qualquer duplicação destes refletirá esse fato.

Portanto, quando você digita algo como o seguinte:

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

Aqui está o que acontece, em ordem:

1. um tubo (fifo) é criado. "comando FD1" está apontado para este canal. "grep FD0" também é apontado para este canal
2. "comando FD2" é apontado para onde "comando FD1" aponta atualmente (o canal)
3. "comando FD1" está apontado para / dev / null

Portanto, toda saída que esse "comando" grava em seu FD 2 (stderr) segue para o canal e é lida por "grep" no outro lado. Toda saída que "comando" grava em seu FD 1 (stdout) chega a / dev / null.

Em vez disso, você executa o seguinte:

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

Aqui está o que acontece:

1. um pipe é criado e "command FD 1" e "grep FD 0" são apontados para ele
2. "comando FD 1" está apontado para / dev / null
3. "comando FD 2" é apontado para onde o FD 1 aponta atualmente (/ dev / null)

Portanto, todos os stdout e stderr do "comando" vão para / dev / null. Nada vai para o canal e, assim, o "grep" será fechado sem exibir nada na tela.

Observe também que os redirecionamentos (descritores de arquivo) podem ser somente leitura (<), somente gravação (>) ou leitura e gravação (<>).

Uma nota final. Se um programa grava algo em FD1 ou FD2, depende inteiramente do programador. As boas práticas de programação determinam que as mensagens de erro devem ir para o FD 2 e a saída normal para o FD 1, mas muitas vezes você encontrará uma programação desleixada que mistura os dois ou ignora a convenção.

Se você estiver usando o Bash, use:

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

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

Para aqueles que desejam redirecionar stdout e stderr permanentemente para arquivos, grep no stderr, mas mantenha o stdout para escrever mensagens em um 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

Isso redirecionará command1 stderr para command2 stdin, deixando o command1 stdout como está.

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

Retirado do LDP

Acabei de criar uma solução para enviar stdoutpara um comando e stderrpara outro, usando pipes nomeados.

Aqui vai.

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

Provavelmente, é uma boa idéia remover os pipes nomeados posteriormente.

Você pode usar o shell rc .

Primeiro instale o pacote (tem menos de 1 MB).

Este um exemplo de como você iria descartar saída padrão e tubo de erro padrão para grep em rc:

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

Você pode fazer isso sem sair do Bash:

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

Como você deve ter notado, é possível especificar qual descritor de arquivo você deseja canalizar usando colchetes após o canal.

Os descritores de arquivo padrão são numerados da seguinte forma:

• 0: entrada padrão
• 1: Saída padrão
• 2: erro padrão

Eu tento seguir, acho que funciona também,

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