¿Cómo no hacer nada para siempre de una manera elegante?

Tengo un programa que produce información útil stdoutpero también lee stdin. Quiero redirigir su salida estándar a un archivo sin proporcionar nada en la entrada estándar. Hasta ahora, todo bien: puedo hacer:

program > output

y no hagas nada en el tty.

Sin embargo, el problema es que quiero hacer esto en segundo plano. Si lo hago:

program > output &

el programa se suspenderá ("suspendido (entrada tty)").

Si lo hago:

program < /dev/null > output &

el programa termina inmediatamente porque llega a EOF.

Parece que lo que necesito es conectarme a programalgo que no hace nada por un tiempo indefinido y que no lee stdin. Los siguientes enfoques funcionan:

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

Sin embargo, todo esto es muy feo. No tiene que ser una manera elegante, con las utilidades estándar de Unix, "no hacer nada, por tiempo indefinido" (parafraseando man true). ¿Cómo podría lograr esto? (Mi criterio principal para la elegancia aquí: sin archivos temporales; sin esperas ocupadas o despertares periódicos; sin utilidades exóticas; lo más corto posible).

En los shells que los admiten (ksh, zsh, bash4), puede comenzar programcomo un coproceso .

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

Eso comienza programen segundo plano con su entrada redirigida desde a pipe. El otro extremo de la tubería está abierto a la carcasa.

Tres beneficios de ese enfoque

• sin proceso extra
• puedes salir del script cuando programmuera (úsalo waitpara esperarlo)
• programterminará (obtenga eofsu stdin si el shell sale).

No creo que te vayas a poner más elegante que el

tail -f /dev/null

que ya sugirió (suponiendo que este uso inotifique internamente, no debería haber encuestas ni reactivaciones, por lo que aparte de tener un aspecto extraño, debería ser suficiente).

Necesita una utilidad que se ejecutará indefinidamente, mantendrá su stdout abierto, pero en realidad no escribirá nada en stdout, y no saldrá cuando se cierre su stdin. Algo así yesrealmente escribe en stdout. catsaldrá cuando su stdin esté cerrado (o lo que sea que redireccione a él está hecho). Creo que sleep 1000000000dpodría funcionar, pero tailclaramente es mejor. Mi cuadro de Debian tiene un tailfcomando que acorta un poco.

Tomando un rumbo diferente, ¿qué tal si ejecutamos el programa screen?

sleep infinity es la solución más clara que conozco.

Puede usar infinityporque sleepacepta un número de coma flotante * , que puede ser decimal , hexadecimal , infinito o NaN , de acuerdo con man strtod.

* Esto no es parte del estándar POSIX, por lo que no es tan portátil como tail -f /dev/null. Sin embargo, es compatible con GNU coreutils (Linux) y BSD (utilizado en Mac) (aparentemente no es compatible con las versiones más nuevas de Mac - ver comentarios).

sleep 2147483647 | program > output &

Sí, 2^31-1es un número finito, y no se ejecutará para siempre , pero te daré $ 1000 cuando el sueño finalmente se agote. (Sugerencia: uno de nosotros estará muerto para entonces).

• sin archivos temporales; cheque.
• sin esperas ocupadas o despertares periódicos; cheque
• sin utilidades exóticas; cheque.
• tan corto como sea posible. De acuerdo, podría ser más corto.

Puede crear un binario que haga exactamente eso con:

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

Aquí hay otra sugerencia usando las utilidades estándar de Unix, para "no hacer nada, indefinidamente" .

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

Esto activa un shell que se envía inmediatamente SIGSTOP, lo que suspende el proceso. Esto se utiliza como "entrada" a su programa. El complemento de SIGSTOPes SIGCONT, es decir, si sabe que el shell tiene PID 12345, puede kill -CONT 12345hacerlo continuar.

En Linux, puedes hacer:

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

En Linux, abrir / dev / fd / x donde x es un descriptor de archivo al final de la escritura de una tubería, le da el final de la lectura de la tubería, así que aquí es lo mismo que en el stdin del programa. Entonces, básicamente, readnunca volverá, porque lo único que puede escribir en esa tubería es en sí mismo, y readno genera nada.

También funcionará en FreeBSD o Solaris, pero por otra razón. Allí, abrir / dev / fd / 1 le da el mismo recurso que abrir en fd 1 como lo esperaría y como la mayoría de los sistemas, excepto Linux, lo hacen al final de la escritura. Sin embargo, en FreeBSD y Solaris, las tuberías son bidireccionales. Por lo tanto, siempre programque no escriba en su stdin (ninguna aplicación lo hace), readno obtendrá nada que leer desde esa dirección de la tubería.

En sistemas donde las tuberías no son bidireccionales, reades probable que falle con un error al intentar leer desde un descriptor de archivo de solo escritura. También tenga en cuenta que no todos los sistemas tienen /dev/fd/x.

La read solución de Stéphane Chazelas también funciona en Mac OS X si se abre un fd de lectura /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/nullen un script (con SIGINT, por ejemplo) es necesario poner en segundo plano el tailcomando y wait.

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

Redireccionar /dev/zerocomo entrada estándar!

program < /dev/zero > output &