Pipe nomeado em buffer sem bloqueio?

Estou procurando por algo que suspeito que não exista: Um pipe nomeado em buffer sem bloqueio (fifo) para uso na linha de comando. Existe uma coisa dessas?

Aqui está o caso de uso: Suponha que eu tenha um processo que demore muito tempo em segundo plano e forneça muita saída para stdout. Eu realmente não me importo com a saída e não quero armazená-la (talvez não tenha espaço suficiente para isso), mas gostaria de "aparecer" periodicamente e seguir o que está fazendo, depois desistir novamente e deixe-o fazer o seu trabalho. Então, eu gostaria de redirecionar sua saída para esse pipe nomeado, com buffer e sem bloqueio teórico, e depois usá-lo periodicamente.

Então, basicamente, eu quero começar assim ( 10Msendo o tamanho do buffer):

mkmagicfifo magicfifo 10M
spewingprocess > magicfifo &

... e periodicamente aparecer para ver o que está acontecendo ...

tail -f magicfifo

... sem magicfifo armazenar toda a saída (portanto, não é um arquivo normal) e sem bloquear o processo de vomitar quando é preenchido e não é aproveitado (portanto, não é um pipe nomeado normal).

Não acho que as soluções envolvam tailou pruneo façam (bem, consigo pensar em uma solução alternativa tail), porque tailainda exigiria que eu armazenasse todos os dados em algum lugar (se eu quiser entrar e sair de olhar para eles), e prunetem que reescrever o arquivo, presumivelmente (admito que não tentei / provei isso) interrompendo o redirecionamento do processo gerando toda a saída.

Eu espero que eu possa escrever algum utilitário para fazer isso, mas o * nix tem tantos aspectos interessantes de arquivos e pipes e outros, eu simplesmente não posso deixar de pensar que isso existe e simplesmente não sei sobre isso.

Então: existe tal coisa e, em caso afirmativo, o que é?

Eu acho que o que você está procurando é o GNU screen. Ele mantém um buffer para manter a última tela cheia ou duas da saída de um ou mais programas e permite desconectar e voltar mais tarde.

Você pode usar pv, ele fornece o buffer que você deseja em um pipeline. Você pode usá-lo assim:

sprewingprocess | pv -B 1g > ordinaryfifo &

Isso daria até 1 GB de buffer entre spewingprocesse o fifo. A maioria das distribuições Linux oferece pvem um pacote chamado, acredite ou não pv,.

Eu tive o mesmo problema. Esta é a minha primeira solução. Primeiro, grave a saída em um arquivo que truncamos após cada linha para que não cresça indefinidamente:

spewingprocess | while read line; do echo $line > buffer.txt ; done

Em seguida, leia o arquivo usando tail (onde 2> /dev/nullse livra da mensagem de erro "arquivo truncado"):

tail -f ./buffer.txt 2> /dev/null

Dessa forma, o buffer não cresce e podemos multiplexar, por exemplo, executar quantas caudas quisermos. No entanto, o problema dessa abordagem é que podemos perder dados quando truncamos mais rapidamente do que a cauda pode ler, como mostra este teste:

for ((i=0; ; i++)) ; do echo "$i" ; done | while read line; do  echo $line > buffer.txt ; done
tail -f ./buffer.txt 2> /dev/null > log.txt

Após algum tempo de execução, a primeira e a última linha são:

$ head -n 1 log.txt
0
$ tail -n 1 log.txt
78783

Mas o arquivo tem menos linhas, então algumas são perdidas:

$ wc log.txt
67087  67087 392819 log.txt

Ainda assim, isso parece uma boa solução, se você não se importa tanto com a perda de dados ou quando o processo de spewing não é rápido o suficiente para a perda de dados.