Дублировать stdout в канал для передачи в другую команду с использованием именованного канала в функции POSIX shell скрипта

mkfifo foo
printf %s\\n bar | tee foo &
tr -s '[:lower:]' '[:upper:]' <foo
wait
rm foo

Это рабочий скрипт POSIX shell, реализующий то, что я хочу сделать:

• printf %s\\n bar символизирует внешнюю программу, создающую stdout
• tr -s '[:lower:]' '[:upper:]' символизирует другую команду, которая должна получить stdout и сделать с ним что-то
• tee дублирует stdout в именованный канал foo

И вывод получается ожидаемым:

bar
BAR

Теперь я бы хотел упростить код, чтобы он выглядел как external_program | my_function. Что-то вроде:

f() (
  mkfifo foo
  tee foo &
  tr -s '[:lower:]' '[:upper:]' <foo
  wait
  rm foo
)
printf %s\\n bar | f

Но теперь вывода нет вовсе.

Суть проблемы в том, что POSIX имеет (обычно не полезное) требование для sh: асинхронные команды должны иметь перенаправленный stdin на /dev/null, если нет явного перенаправления stdin (впрочем, технически, это неявное перенаправление на /dev/null происходит перед явными перенаправлениями, если они есть).

Посмотрите, например, на Linux-системах:

$ sh -c 'realpath /dev/stdin & wait'
/dev/null

Общее решение для асинхронной команды, чтобы stdin оставался нетронутым, заключается в следующем:

{ cmd <&3 3<&- & } 3<&0

Где исходный stdin доступен на fd 3 в дополнение к 0 в группе команд с 3<&0, и внутри группы команд cmd stdin, который был снова открыт на /dev/null из-за & перенаправляется обратно на исходный stdin через этот fd 3 (который мы затем закрываем, так как он больше не нужен).

В:

f() (
  mkfifo foo
  tee foo &
  tr -s '[:lower:]' '[:upper:]' <foo
  rm foo
)
printf %s\\n bar | f

stdin tee будет /dev/null, а не концом канала чтения от printf. Изменение на:

f() (
  mkfifo foo
  { tee foo <&3 3<&- & } 3<&0
  tr -s '[:lower:]' '[:upper:]' <foo
  rm foo
  wait
)
printf '%s\n' bar | f

решит проблему, но как вы обнаружили, так же поможет

f() (
  mkfifo foo
  tr -s '[:lower:]' '[:upper:]' <foo &
  tee foo
  rm foo
)
printf %s\\n bar | f

Тогда tee не запускается асинхронно, поэтому его stdin не перенаправляется на /dev/null, а stdin tr перенаправляется явно, так что не имеет значения, что он был перенаправлен на /dev/null заранее.

Также нам не нужно wait, так как tee — это процесс, выполняющийся синхронно (и поэтому ожидаемый implicitly shell) и обычно не завершается перед tr, так как ожидает eof на своем stdin (а stdout tr, который является противоположным концом этого канала, закрывается только после выхода).

Возможно, вы все-таки захотите дождаться завершения tr, чтобы получить код его выхода:

f() (
  ret=0
  mkfifo foo || exit
  tr -s '[:lower:]' '[:upper:]' <foo &
  tee foo || ret=$?
  rm -f foo
  wait "$!" || ret=$?
  exit "$ret"
)
printf '%s\n' bar | f

foo не будет удален, если подпроцесс, являющийся телом функции, завершится. Вы можете сократить время существования fifo и сделать его даже более похожим на неназванный канал (где именованный канал — это просто эфемерное место встречи для этих двух процессов к установлению канала), удалив его, как только он будет открыт в режимах чтения и записи обоими процессами.

f() (
  ret=0
  mkfifo foo || exit
  { tee foo <&3 3<&- & } 3<&0
  {
    # на данный момент, foo уже будет открыт здесь в режиме только для чтения
    # на stdin, что может произойти только в том случае,
    # если tee уже открыл его в режиме только для записи.
    rm -f foo
    tr -s '[:lower:]' '[:upper:]' || ret=$?
  } < foo
  wait "$!" || ret=$?
  exit "$ret"
)
printf '%s\n' bar | f

Похоже, что проблема, как и предполагалось, заключается в попытке передать external_program в отсоединенный tee.

В оригинальном скрипте было:

printf %s\\n bar | tee foo &

Что не отсоединяет только tee, а всю последовательность pipe целиком. Изначально я сделал такую же конструкцию pipe, которая разрешается немедленно, то есть и sleep и пустая операция : отсоединяются вместе:

$ time sh -c 'sleep 10 | : &'

real    0m0.001s
user    0m0.000s
sys     0m0.001s

Однако, при отсоединении tee внутри функции, отсоединяется только tee, а не внешняя программа в начале pipe. Повторяя пример со sleep, мы можем видеть, что отсоединяется только пустая операция :, но sleep — нет, и скрипт занимает все 10 секунд:

$ time sh -c 'sleep 10 | { : & }'

real    0m10.002s
user    0m0.002s
sys     0m0.000s

Решение заключается в том, чтобы не отсоединять tee, а другую команду:

f() (
  mkfifo foo
  tr -s '[:lower:]' '[:upper:]' <foo &
  tee foo
  wait
  rm foo
)
printf %s\\n bar | f

Теперь tee может получать stdout из pipe, записывать в FIFO, и выход функции снова будет:

bar
BAR