Como unir dois pipes nomeados no fluxo de entrada único no linux

Usando o |recurso pipes ( ) no Linux, posso encadear a entrada padrão para um ou vários fluxos de saída.

Eu posso usar teepara dividir a saída para separar sub processos.

Existe um comando para unir dois fluxos de entrada?

Como eu iria fazer isso? Como o diff funciona?

Pessoalmente, meu favorito (requer bash e outras coisas que são padrão na maioria das distribuições Linux)

Os detalhes podem depender muito do resultado das duas coisas e como você deseja mesclá-las ...

Conteúdo de command1 e command2 um após o outro na saída:

cat <(command1) <(command2) > outputfile

Ou se os dois comandos produzirem versões alternativas dos mesmos dados que você deseja ver lado a lado (eu usei isso com o snmpwalk; números de um lado e nomes MIB do outro):

paste <(command1) <(command2) > outputfile

Ou se você deseja comparar a saída de dois comandos semelhantes (digamos, encontrar em dois diretórios diferentes)

diff <(command1) <(command2) > outputfile

Ou, se houver algum tipo de saída ordenada, mescle-as:

sort -m <(command1) <(command2) > outputfile

Ou execute os dois comandos de uma só vez (no entanto, você pode embaralhar um pouco as coisas):

cat <(command1 & command2) > outputfile

O operador <() configura um pipe nomeado (ou / dev / fd) para cada comando, canalizando a saída desse comando no pipe nomeado (ou / dev / fd filehandle reference) e passa o nome na linha de comando. Existe um equivalente a> (). Você pode fazer: command0 | tee >(command1) >(command2) >(command3) | command4enviar simultaneamente a saída de um comando para 4 outros comandos, por exemplo.

Você pode anexar dois vapores a outro com cat, como mostra o gorila.

Você também pode criar um FIFO, direcionar a saída dos comandos para isso e ler o FIFO com qualquer outro programa:

mkfifo ~/my_fifo
command1 > ~/my_fifo &
command2 > ~/my_fifo &
command3 < ~/my_fifo

Particularmente útil para programas que gravam ou leem apenas um arquivo, ou misturam programas que produzem apenas stdout / file com um que suporta apenas o outro.

(tail -f /tmp/p1 & tail -f /tmp/p2 ) | cat > /tmp/output

/tmp/p1e /tmp/p2são seus canais de entrada, enquanto /tmp/outputé a saída.

Eu criei um programa especial para isso: fdlinecombine

Ele lê vários pipes (geralmente saídas de programas) e os grava no stdout linewise (você também pode substituir o separador)

Um comando muito legal que usei para isso é que tpipevocê pode precisar compilar porque não é tão comum. É realmente ótimo para fazer exatamente do que você está falando, e é tão limpo que eu costumo instalá-lo. A página de manual está localizada aqui http://linux.die.net/man/1/tpipe . O download listado atualmente está neste arquivo http://www.eurogaran.com/downloads/tpipe/ .

É usado assim,

## Reinject sub-pipeline stdout into standard output:
$ pipeline1 | tpipe "pipeline2" | pipeline3

Tenha cuidado aqui; apenas colocá-los acabará misturando os resultados de maneiras que você não deseja: por exemplo, se forem arquivos de log, você provavelmente não quer uma linha de uma inserida no meio da linha e na outra. Se estiver tudo bem, então

tail -f / tmp / p1 / tmp / p2> / tmp / saída

vai funcionar. Se não estiver tudo bem, você terá que encontrar algo que faça buffer de linha e só produza linhas completas. O Syslog faz isso, mas não tenho certeza do que mais possa.

EDIT: otimização para leitura sem buffer e pipes nomeados:

considerando / tmp / p1, / ​​tmp / p2, / tmp / p3 como pipes nomeados, criados por "mkfifo / tmp / p N "

cauda -q -f / tmp / p1 / tmp / p2 | awk '{print $ 0> "/ tmp / p3"; fechar ("/ tmp / p3"); fflush ();} '&

Agora, dessa maneira, podemos ler o canal chamado Output "/ tmp / p3" sem buffer por:

cauda -f / tmp / p3

existe um pequeno bug do tipo, você precisa "inicializar" o primeiro canal de entrada / tmp / p1:

eco -n> / tmp / p1

para atender , aceitará a entrada do segundo pipe / tmp / p2 primeiro e não espere até que algo chegue a / tmp / p1. pode não ser o caso, se você tiver certeza, o / tmp / p1 receberá a entrada primeiro.

Além disso, a opção -q é necessária para que a cauda não imprima lixo sobre os nomes de arquivos.

O melhor programa para fazer isso é lmerge. Diferentemente da resposta do freihart, ela é orientada a linhas, de modo que a saída dos dois comandos não se derruba. Ao contrário de outras soluções, ele mescla a entrada de maneira justa, de modo que nenhum comando possa dominar a saída. Por exemplo:

$ lmerge <(yes foo) <(yes bar) | head -n 4

Dá saída de:

foo
bar
foo
bar