Como não fazer nada para sempre de uma maneira elegante?

Eu tenho um programa que produz informações úteis, stdoutmas também lê stdin. Quero redirecionar sua saída padrão para um arquivo sem fornecer nada na entrada padrão. Até agora, tudo bem: eu posso fazer:

program > output

e não faça nada no tty.

No entanto, o problema é que eu quero fazer isso em segundo plano. Se eu fizer:

program > output &

o programa será suspenso ("suspendido (entrada tty)").

Se eu fizer:

program < /dev/null > output &

o programa termina imediatamente porque alcança EOF.

Parece que o que preciso é canalizar para programalgo que não faz nada por um período indefinido de tempo e não lê stdin. As abordagens a seguir funcionam:

while true; do sleep 100; done | program > output &
mkfifo fifo && cat fifo | program > output &
tail -f /dev/null | program > output &

No entanto, tudo isso é muito feio. Não tem que ser uma maneira elegante, usando utilitários Unix padrão, para "não fazer nada, por tempo indeterminado" (parafraseando man true). Como eu consegui isso? (Meus principais critérios de elegância aqui: sem arquivos temporários; sem espera ocupada ou ativações periódicas; sem utilitários exóticos; o mais curto possível).

Nos shells que os suportam (ksh, zsh, bash4), você pode iniciar programcomo um co-processo .

• ksh: program > output |&
• zsh, bash:coproc program > output

Isso começa programem segundo plano com sua entrada redirecionada de a pipe. A outra extremidade do tubo está aberta para a concha.

Três benefícios dessa abordagem

• nenhum processo extra
• você pode sair do script quando programmorrer (use waitpara esperar)
• programterminará (entre eofem seu stdin se o shell sair).

Eu não acho que você vai ficar mais elegante que o

tail -f /dev/null

que você já sugeriu (supondo que esse uso seja inotificado internamente, não deve haver pesquisas ou despertares; portanto, além de ter uma aparência estranha, deve ser suficiente).

Você precisa de um utilitário que funcione indefinidamente, manterá o stdout aberto, mas não gravará nada no stdout e não sairá quando o stdin estiver fechado. Algo como yesrealmente escreve para stdout. catsairá quando o stdin estiver fechado (ou o que você redirecionar para ele estiver pronto). Eu acho que sleep 1000000000dpode funcionar, mas tailé claramente melhor. Minha caixa Debian tem um tailfcomando que encurta um pouco.

Tomando uma abordagem diferente, que tal executar o programa screen?

sleep infinity é a solução mais clara que conheço.

Você pode usar infinityporque sleepaceita um número de ponto flutuante * , que pode ser decimal , hexadecimal , infinito ou NaN , de acordo com man strtod.

* Isso não faz parte do padrão POSIX, portanto não é tão portátil quanto tail -f /dev/null. No entanto, ele é suportado no GNU coreutils (Linux) e no BSD (usado no Mac) (aparentemente não suportado nas versões mais recentes do Mac - veja comentários).

sleep 2147483647 | program > output &

Sim, 2^31-1é um número finito e não durará para sempre , mas darei $ 1000 quando o sono finalmente terminar. (Dica: um de nós estará morto até então.)

• sem arquivos temporários; Verifica.
• sem espera ocupada ou despertares periódicos; Verifica
• sem utilidades exóticas; Verifica.
• o mais curto possível. Ok, poderia ser mais curto.

Você pode criar um binário que faça exatamente isso com:

$ echo 'int main(){ pause(); }' > pause.c; make pause

Aqui está outra sugestão, usando os utilitários padrão do Unix, para "não fazer nada indefinidamente" .

sh -c 'kill -STOP $$' | program > output

Isso aciona um shell que é enviado imediatamente SIGSTOP, o que suspende o processo. Isso é usado como "entrada" para o seu programa. O complemento de SIGSTOPé SIGCONT, ou seja, se você sabe que o shell possui 12345 PID, pode kill -CONT 12345fazê-lo continuar.

No Linux, você pode fazer:

read x < /dev/fd/1 | program > output

No Linux, abrir / dev / fd / x onde x é um descritor de arquivo para a extremidade de gravação de um canal, fornece a extremidade de leitura do canal, então aqui é o mesmo que no stdin do programa. Então, basicamente, readnunca retornará, porque a única coisa que pode gravar nesse canal é ela mesma e readnão gera nada.

Também funcionará no FreeBSD ou Solaris, mas por outro motivo. Lá, abrir / dev / fd / 1 fornece o mesmo recurso que abrir no fd 1, como você esperaria e como a maioria dos sistemas, exceto o Linux, o que significa que é o fim da escrita. No entanto, no FreeBSD e Solaris, os pipes são bidirecionais. Portanto, contanto programque não escreva em seu stdin (nenhum aplicativo faz), não readhaverá nada para ler nessa direção do pipe.

Nos sistemas em que os pipes não são bidirecionais, readprovavelmente ocorrerá um erro ao tentar ler um descritor de arquivo somente gravação. Observe também que nem todos os sistemas possuem /dev/fd/x.

A read solução de Stéphane Chazelas também funciona no Mac OS X se uma leitura fd for aberta /dev/fd/1.

# using bash on Mac OS X
# -bash: /dev/fd/1: Permission denied
read x </dev/fd/1 | cat >/dev/null
echo ${PIPESTATUS[*]}   #  1 0

exec 3<&- 3</dev/fd/1
read x 0<&3 | cat >/dev/null
echo ${PIPESTATUS[*]}   #  0 0

Para poder matar tail -f /dev/nullem um script (com o SIGINT, por exemplo), é necessário fazer o background do tailcomando e wait.

#!/bin/bash
# ctrl-c will kill tail and exit script
trap 'trap - INT; kill "$!"; exit' INT
exec tail -f /dev/null & wait $!

Redirecionar /dev/zerocomo entrada padrão!

program < /dev/zero > output &