Comment ne rien faire pour toujours de manière élégante?

J'ai un programme qui produit des informations utiles sur stdoutmais lit également stdin. Je veux rediriger sa sortie standard vers un fichier sans rien fournir en entrée standard. Jusqu'ici, tout va bien: je peux faire:

program > output

et ne fais rien dans le tty.

Cependant, le problème est que je veux le faire en arrière-plan. Si je fais:

program > output &

le programme sera suspendu ("suspendu (entrée tty)").

Si je fais:

program < /dev/null > output &

le programme se termine immédiatement car il atteint EOF.

Il me semble que ce dont j'ai besoin, c'est de pénétrer dans programquelque chose qui ne fait rien pendant une durée indéterminée et qui ne lit pas stdin. Les approches suivantes fonctionnent:

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

Cependant, tout cela est très moche. Il doit y avoir un moyen élégant, en utilisant les utilitaires Unix standard, de "ne rien faire, indéfiniment" (pour paraphraser man true). Comment pourrais-je y parvenir? (Mes principaux critères d'élégance sont les suivants: pas de fichiers temporaires, pas de files d'attente trop fréquentes ni de réveils périodiques; pas de services publics exotiques; aussi court que possible.)

Dans les shells qui les prennent en charge (ksh, zsh, bash4), vous pouvez commencer en programtant que co-processus .

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

Cela commence programen arrière-plan avec son entrée redirigée depuis un fichier pipe. L'autre extrémité du tuyau est ouverte à la coque.

Trois avantages de cette approche

• pas de processus supplémentaire
• vous pouvez quitter le script quand il programmeurt (utilisez-le waitpour l'attendre)
• programse terminera (obtiendrez eofson stdin si le shell se ferme).

Je ne pense pas que vous allez devenir plus élégant que le

tail -f /dev/null

que vous avez déjà suggéré (en supposant que cela utilise inotify en interne, il ne devrait pas y avoir d’interrogation ni de réveil, de sorte qu’autre chose qu’elle soit étrange, elle devrait être suffisante).

Vous avez besoin d'un utilitaire qui s'exécutera indéfiniment, gardera son stdout ouvert, mais n'écrira rien sur stdout et ne se fermera pas lorsque son stdin sera fermé. Quelque chose comme yesécrit en fait sur stdout. catquittera quand son stdin sera fermé (ou ce que vous redirigerez dedans est fait). Je pense que cela sleep 1000000000dpourrait marcher, mais tailc'est nettement mieux. Ma boîte Debian a une tailfcommande qui raccourcit légèrement.

Sous un angle différent, que diriez-vous de lancer le programme screen?

sleep infinity est la solution la plus claire que je connaisse.

Vous pouvez utiliser infinitycar sleepaccepte un nombre à virgule flottante * , qui peut être décimal , hexadécimal , infini ou NaN , selon man strtod.

* Cela ne fait pas partie de la norme POSIX et n’est donc pas aussi portable tail -f /dev/null. Cependant, il est supporté par GNU coreutils (Linux) et BSD (utilisé sur Mac) (apparemment pas supporté par les versions plus récentes de Mac - voir les commentaires).

sleep 2147483647 | program > output &

Oui, 2^31-1c'est un nombre fini, et il ne fonctionnera pas éternellement , mais je vous donnerai 1 000 $ lorsque le sommeil aura finalement expiré. (Indice: l'un de nous sera mort d'ici là.)

• aucun fichier temporaire; vérifier.
• pas de réveil occupé ou périodique; vérifier
• pas de services publics exotiques; vérifier.
• aussi court que possible. Ok, ça pourrait être plus court.

Vous pouvez créer un binaire qui fait exactement cela avec:

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

Voici une autre suggestion utilisant les utilitaires Unix standard, pour "ne rien faire, indéfiniment" .

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

Cela déclenche un shell qui est immédiatement envoyé SIGSTOP, ce qui suspend le processus. Ceci est utilisé comme "entrée" dans votre programme. Le complément de SIGSTOPis SIGCONT, c’est-à-dire que si vous savez que le shell a le PID 12345, vous pouvez kill -CONT 12345le faire continuer.

Sous Linux, vous pouvez faire:

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

Sous Linux, l’ouverture de / dev / fd / x, où x est un descripteur de fichier situé à la fin de l’écriture d’un pipe, vous donne la fin de la lecture du tuyau, donc la même chose que sur le stdin du programme. Donc, fondamentalement, readne reviendra jamais, car la seule chose qui peut écrire dans ce canal est elle-même et readne génère rien.

Cela fonctionnera également sur FreeBSD ou Solaris, mais pour une autre raison. Là, en ouvrant / dev / fd / 1, vous obtenez la même ressource que celle que vous attendez sur fd 1 et comme le font la plupart des systèmes, à l’exception de Linux, donc en fin d’écriture. Cependant, sous FreeBSD et Solaris, les tuyaux sont bidirectionnels. Donc tant qu’il programn’écrit pas dans son stdin (aucune application ne le fait), readrien n’est lu de cette direction du tuyau.

Sur les systèmes où les canaux ne sont pas bidirectionnels, il y readaura probablement une erreur lors de la tentative de lecture à partir d'un descripteur de fichier en écriture seule. Notez également que tous les systèmes ne l’ont pas /dev/fd/x.

La read solution de Stéphane Chazelas fonctionne également sur Mac OS X si un fichier de lecture est ouvert /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

Pour pouvoir tuer tail -f /dev/nulldans un script (avec SIGINT, par exemple), il est nécessaire de mettre en arrière-plan la tailcommande et wait.

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

Rediriger en /dev/zerotant qu'entrée standard!

program < /dev/zero > output &