Как ничего не делать вечно элегантным способом?

У меня есть программа, которая производит полезную информацию, stdoutно также читает из stdin. Я хочу перенаправить его стандартный вывод в файл, не предоставляя ничего для стандартного ввода. Пока все хорошо, я могу сделать:

program > output

и не делай ничего в tty.

Однако проблема в том, что я хочу сделать это в фоновом режиме. Если я сделаю:

program > output &

программа будет приостановлена ​​(«приостановлено (tty input)»).

Если я сделаю:

program < /dev/null > output &

программа немедленно завершается, потому что она достигает EOF.

Кажется, что мне нужно подключиться к programчему-то, что ничего не делает в течение неопределенного времени и не читает stdin. Работают следующие подходы:

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

Однако все это очень некрасиво. Там есть быть элегантным способом, с помощью стандартного утилита Unix, не «ничего не делать, до бесконечности» (перефразируя man true). Как я мог этого добиться? (Мои главные критерии элегантности здесь: никаких временных файлов; никаких занятых или периодических пробуждений; никаких экзотических утилит; как можно короче.)

В оболочках, которые их поддерживают (ksh, zsh, bash4), вы можете начать programкак совместный процесс .

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

Это начинается programв фоновом режиме с ввода, перенаправленного из pipe. Другой конец трубы открыт для оболочки.

Три преимущества такого подхода

• без дополнительного процесса
• вы можете выйти из скрипта, когда programумрете (используйте, waitчтобы ждать его)
• programзавершится (войдите eofв свой стандартный ввод, если оболочка выйдет).

Я не думаю, что ты станешь более элегантным, чем

tail -f /dev/null

что вы уже предложили (при условии, что для внутреннего использования используется inotify, опросов или пробуждений не должно быть, поэтому, кроме странного вида, этого должно быть достаточно).

Вам нужна утилита, которая будет работать неопределенно долго, будет держать свой стандартный вывод открытым, но на самом деле ничего не будет записывать в стандартный вывод и не будет завершать работу, когда ее стандартный вывод закрыт. Нечто подобное на yesсамом деле пишет в стандартный вывод. catвыйдет, когда его стандартный ввод будет закрыт (или все, что вы перенаправили в него, будет сделано). Я думаю, что sleep 1000000000dможет работать, но tailявно лучше. В моей коробке Debian есть tailfкоманда, которая немного укорачивает команду.

Взять другой курс, как насчет запуска программы под screen?

sleep infinity это самое ясное решение, которое я знаю.

Вы можете использовать, infinityпотому что sleepпринимает число с плавающей запятой * , которое может быть десятичным , шестнадцатеричным , бесконечностью или NaN , в соответствии с man strtod.

* Это не является частью стандарта POSIX, поэтому не так переносимо, как tail -f /dev/null. Однако он поддерживается в GNU coreutils (Linux) и BSD (используется на Mac) (очевидно, не поддерживается в более новых версиях Mac - см. Комментарии).

sleep 2147483647 | program > output &

Да, 2^31-1это конечное число, и оно не будет работать вечно , но я дам вам 1000 долларов, когда время сна наконец истечет. (Подсказка: один из нас к тому времени умрет.)

• нет временных файлов; проверить.
• нет занятых ожиданий или периодических пробуждений; проверить
• никаких экзотических утилит; проверить.
• как можно короче. Хорошо, это может быть короче.

Вы можете создать двоичный файл, который делает это с:

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

Вот еще одно предложение использовать стандартные утилиты Unix, чтобы «ничего не делать, бесконечно» .

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

Это запускает оболочку, которая немедленно отправляется SIGSTOP, что приостанавливает процесс. Это используется как «вход» в вашу программу. Дополнением SIGSTOPявляется SIGCONT, т.е. если вы знаете, что оболочка имеет PID 12345, вы можете kill -CONT 12345сделать так, чтобы она продолжалась.

В Linux вы можете сделать:

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

В Linux, открыв / dev / fd / x, где x - дескриптор файла для конца записи канала, вы получите конец чтения канала, так что здесь то же самое, что и в stdin программы. Так что, по сути, readникогда не вернется, потому что единственное, что может записать в этот канал, это само по себе, и readничего не выводит.

Он также будет работать на FreeBSD или Solaris, но по другой причине. Там, открыв / dev / fd / 1, вы получите тот же ресурс, что и open на fd 1, как и следовало ожидать, и как и большинство систем, кроме Linux, так что конец написания канала. Однако в FreeBSD и Solaris каналы являются двунаправленными. Поэтому до тех пор, пока programон не пишет в свой стандартный ввод (ни одно приложение не делает этого), он readне получит ничего, чтобы читать с этого направления канала.

В системах, где каналы не являются двунаправленными, readвероятно , произойдет сбой с ошибкой при попытке чтения из дескриптора файла только для записи. Также обратите внимание, что не все системы имеют /dev/fd/x.

read Решение Стефана Чазела работает и на Mac OS X, если открыто чтение с 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

Чтобы иметь возможность убивать tail -f /dev/nullв скрипте (например, с помощью SIGINT), необходимо выполнить tailкоманду background и wait.

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

Перенаправить /dev/zeroкак стандартный ввод!

program < /dev/zero > output &