Come non fare nulla per sempre in modo elegante?

Ho un programma che produce informazioni utili stdoutma che legge anche stdin. Voglio reindirizzare il suo output standard su un file senza fornire nulla sull'input standard. Fin qui tutto bene: posso fare:

program > output

e non fare nulla nel tty.

Tuttavia, il problema è che voglio farlo in background. Se lo faccio:

program > output &

il programma verrà sospeso ("sospeso (input tty)").

Se lo faccio:

program < /dev/null > output &

il programma termina immediatamente perché raggiunge EOF.

Sembra che ciò di cui ho bisogno sia convogliare programqualcosa che non fa nulla per un tempo indefinito e che non legge stdin. I seguenti approcci funzionano:

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

Tuttavia, è tutto molto brutto. Ci deve essere un modo elegante, utilizzando le utility Unix standard, a "non fare nulla, a tempo indeterminato" (parafrasando man true). Come ho potuto raggiungere questo obiettivo? (I miei criteri principali per l'eleganza qui: nessun file temporaneo; nessuna attesa in attesa o riattivazione periodica; nessuna utilità esotica; il più breve possibile.)

In conchiglie che li (ksh, zsh, bash4) supportano, si può iniziare programcome un co-processo .

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

Quello inizia programin background con il suo input reindirizzato da a pipe. L'altra estremità del tubo è aperta al guscio.

Tre vantaggi di questo approccio

• nessun processo aggiuntivo
• puoi uscire dallo script quando programmuore (usa waitper aspettarlo)
• programterminerà (salire eofsul suo stdin se la shell esce).

Non credo che diventerai più elegante del

tail -f /dev/null

che hai già suggerito (supponendo che questo usi inotificano internamente, non dovrebbero esserci polling o riattivazioni, quindi oltre ad essere strano, dovrebbe essere sufficiente).

È necessaria un'utilità che funzionerà a tempo indeterminato, manterrà il suo stdout aperto, ma in realtà non scriverà nulla su stdout e non uscirà quando il suo stdin è chiuso. Qualcosa del genere in yesrealtà scrive su stdout. catuscirà quando il suo stdin è chiuso (o qualsiasi cosa tu abbia reindirizzato al suo interno). Penso che sleep 1000000000dpotrebbe funzionare, ma tailè chiaramente meglio. La mia casella Debian ha un tailfcomando che accorcia leggermente.

Prendendo una virata diversa, che ne dici di eseguire il programma sotto screen?

sleep infinity è la soluzione più chiara che io conosca.

Puoi usarlo infinityperché sleepaccetta un numero in virgola mobile * , che può essere decimale , esadecimale , infinito o NaN , secondo man strtod.

* Questo non fa parte dello standard POSIX, quindi non è portatile come tail -f /dev/null. Tuttavia, è supportato in GNU coreutils (Linux) e BSD (usato su Mac) (apparentemente non supportato su versioni più recenti di Mac - vedi commenti).

sleep 2147483647 | program > output &

Sì, 2^31-1è un numero finito e non funzionerà per sempre , ma ti darò $ 1000 quando il sonno finirà finalmente. (Suggerimento: uno di noi sarà morto per allora.)

• nessun file temporaneo; dai un'occhiata.
• nessuna sveglia in attesa o periodica; dai un'occhiata
• nessuna utilità esotica; dai un'occhiata.
• il più corto possibile. Va bene, potrebbe essere più breve.

Puoi creare un binario che fa proprio questo con:

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

Ecco un altro suggerimento che utilizza le utility Unix standard, per "non fare nulla, a tempo indeterminato" .

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

Questo attiva una shell che viene immediatamente inviata SIGSTOP, che sospende il processo. Questo è usato come "input" per il tuo programma. Il complemento di SIGSTOPè SIGCONT, ovvero se sai che la shell ha PID 12345 puoi kill -CONT 12345farlo continuare.

Su Linux, puoi fare:

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

Su Linux, aprendo / dev / fd / x dove x è un descrittore di file all'estremità di scrittura di una pipe, ottieni la fine di lettura della pipe, quindi qui lo stesso dello stdin del programma. Quindi, fondamentalmente, readnon tornerà mai più, perché l'unica cosa che può scrivere su quella pipe è se stessa e readnon produce nulla.

Funzionerà anche su FreeBSD o Solaris, ma per un altro motivo. Lì, aprendo / dev / fd / 1 ottieni la stessa risorsa di open su fd 1 come ti aspetteresti e come la maggior parte dei sistemi tranne Linux, quindi la fine della scrittura della pipe. Tuttavia, su FreeBSD e Solaris, i tubi sono bidirezionali. Quindi fino a quando programnon scrive sul suo stdin (nessuna applicazione lo fa), readnon otterrà nulla da leggere da quella direzione della pipe.

Sui sistemi in cui le pipe non sono bidirezionali, readprobabilmente falliranno con un errore quando si tenta di leggere da un descrittore di file di sola scrittura. Si noti inoltre che non tutti i sistemi hanno /dev/fd/x.

La read soluzione di Stéphane Chazelas funziona anche su Mac OS X se viene aperta una lettura fd /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

Per poter uccidere tail -f /dev/nullin uno script (con SIGINT, per esempio) è necessario mettere in background il 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 $!

Reindirizzamento /dev/zerocome input standard!

program < /dev/zero > output &