Bash: stwórz anonimowy fifo

Wszyscy wiemy mkfifoi rurociągi. Pierwszy tworzy nazwaną potok, dlatego należy wybrać nazwę, najprawdopodobniej za pomocą, mktempa później pamiętać, aby rozłączyć. Drugi tworzy anonimową potok, bez kłopotów z nazwami i usuwaniem, ale końce potoku są powiązane z poleceniami w potoku, nie jest tak naprawdę wygodne, aby jakoś uchwycić deskryptory plików i użyć ich w pozostałej części skryptu. W skompilowanym programie po prostu bym to zrobił ret=pipe(filedes); w Bash jest exec 5<>filewięc coś, czego można się spodziewać "exec 5<> -"lub czy "pipe <5 >6"jest coś takiego w Bash?

Możesz odłączyć nazwany potok natychmiast po dołączeniu go do bieżącego procesu, co praktycznie skutkuje anonimowym potokiem:

# create a temporary named pipe
PIPE=$(mktemp -u)
mkfifo $PIPE
# attach it to file descriptor 3
exec 3<>$PIPE
# unlink the named pipe
rm $PIPE
...
# anything we write to fd 3 can be read back from it
echo 'Hello world!' >&3
head -n1 <&3
...
# close the file descriptor when we are finished (optional)
exec 3>&-

Jeśli naprawdę chcesz uniknąć nazwanych potoków (np. System plików jest tylko do odczytu), działa również pomysł „obejrzyj deskryptory plików”. Zauważ, że jest to specyficzne dla Linuksa ze względu na użycie procfs.

# start a background pipeline with two processes running forever
tail -f /dev/null | tail -f /dev/null &
# save the process ids
PID2=$!
PID1=$(jobs -p %+)
# hijack the pipe's file descriptors using procfs
exec 3>/proc/$PID1/fd/1 4</proc/$PID2/fd/0
# kill the background processes we no longer need
# (using disown suppresses the 'Terminated' message)
disown $PID2
kill $PID1 $PID2
...
# anything we write to fd 3 can be read back from fd 4
echo 'Hello world!' >&3
head -n1 <&4
...
# close the file descriptors when we are finished (optional)
exec 3>&- 4<&-

Chociaż żadna ze znanych mi powłok nie może tworzyć rur bez rozwidlenia, niektóre mają lepsze niż podstawowy potok powłoki.

W bash, ksh i zsh, zakładając, że twój system obsługuje /dev/fd(większość obecnie robi), możesz powiązać dane wejściowe lub wyjściowe polecenia z nazwą pliku: <(command)rozwija się do nazwy pliku, która oznacza potok podłączony do wyjścia commandi >(command)rozwija do nazwy pliku oznaczającej potok podłączony do wejścia command. Ta funkcja nosi nazwę zastępowania procesu . Jego głównym celem jest potokowanie więcej niż jednego polecenia do lub z drugiego, np.

diff <(transform <file1) <(transform <file2)
tee >(transform1 >out1) >(transform2 >out2)

Jest to również przydatne w walce z niektórymi wadami podstawowych rur osłonowych. Na przykład command2 < <(command1)jest równoważne command1 | command2, z wyjątkiem tego, że ma status command2. Innym przypadkiem użycia jest exec > >(postprocessing), co jest równoważne, ale bardziej czytelne niż, umieszczenie całej reszty skryptu w środku { ... } | postprocessing.

Bash 4 ma koprocesy .

Koproces wykonywany jest asynchronicznie w podpowłoce, tak jakby polecenie zostało zakończone za pomocą operatora sterującego „&”, z dwukierunkowym potokiem ustanowionym między wykonującą powłoką a koprocesem.

Format koprocesu to:

coproc [NAME] command [redirections] 

Według stanu na październik 2012 r. Ta funkcjonalność nadal nie istnieje w Bash, ale można użyć coproc, jeśli potrzebujesz tylko nienazwanych / anonimowych potoków, aby porozmawiać z procesem potomnym. Problem z coproc w tym momencie polega na tym, że najwyraźniej obsługiwany jest tylko jeden na raz. Nie mogę zrozumieć, dlaczego Coproc ma takie ograniczenie. Powinny one być ulepszeniem istniejącego kodu tła zadań (& &), ale to jest pytanie do autorów bash.

Choć @ DavidAnderson za odpowiedź obejmuje wszystkie podstawy i oferuje jedne zabezpieczeniach ładne, najważniejszą rzeczą jest to, że ujawnia się w swoje ręce anonimowego rury jest tak proste, jak <(:), jak długo pozostanie w systemie Linux.

Zatem najkrótsza i najprostsza odpowiedź na twoje pytanie to:

exec 5<> <(:)

W systemie macOS to nie zadziała, wtedy musisz utworzyć tymczasowy katalog, w którym mieści się nazwany fifo, dopóki nie przekierujesz do niego. Nie wiem o innych BSD.

Poniższa funkcja została przetestowana przy użyciu GNU bash, version 4.4.19(1)-release (x86_64-pc-linux-gnu). System operacyjny to Ubuntu 18. Ta funkcja przyjmuje jeden parametr, który jest pożądanym deskryptorem pliku dla anonimowego FIFO.

MakeFIFO() {
    local "MakeFIFO_upper=$(ulimit -n)" 
    if [[ $# -ne 1 || ${#1} -gt ${#MakeFIFO_upper} || -n ${1%%[0-9]*} || 10#$1 -le 2
        || 10#$1 -ge MakeFIFO_upper ]] || eval ! exec "$1<> " <(:) 2>"/dev/null"; then
        echo "$FUNCNAME: $1: Could not create FIFO" >&2
        return "1"
    fi
}

Poniższa funkcja została przetestowana przy użyciu GNU bash, version 3.2.57(1)-release (x86_64-apple-darwin17). System operacyjny to macOS High Sierra. Ta funkcja zaczyna się od utworzenia nazwanego FIFO w katalogu tymczasowym znanym tylko procesowi, który go utworzył . Następnie deskryptor pliku zostaje przekierowany do FIFO. Na koniec FIFO jest odłączany od nazwy pliku poprzez usunięcie katalogu tymczasowego. To sprawia, że ​​FIFO jest anonimowy.

MakeFIFO() {
    MakeFIFO.SetStatus() {
        return "${1:-$?}"
    }
    MakeFIFO.CleanUp() {
        local "MakeFIFO_status=$?"
        rm -rf "${MakeFIFO_directory:-}"    
        unset "MakeFIFO_directory"
        MakeFIFO.SetStatus "$MakeFIFO_status" && true
        eval eval "${MakeFIFO_handler:-:}'; true'" 
    }
    local "MakeFIFO_success=false" "MakeFIFO_upper=$(ulimit -n)" "MakeFIFO_file=" 
    MakeFIFO_handler="$(trap -p EXIT)"
    MakeFIFO_handler="${MakeFIFO_handler#trap -- }"
    MakeFIFO_handler="${MakeFIFO_handler% *}"
    trap -- 'MakeFIFO.CleanUp' EXIT
    until "$MakeFIFO_success"; do
        [[ $# -eq 1 && ${#1} -le ${#MakeFIFO_upper} && -z ${1%%[0-9]*}
        && 10#$1 -gt 2 && 10#$1 -lt MakeFIFO_upper ]] || break
        MakeFIFO_directory=$(mktemp -d) 2>"/dev/null" || break
        MakeFIFO_file="$MakeFIFO_directory/pipe"
        mkfifo -m 600 $MakeFIFO_file 2>"/dev/null" || break
        ! eval ! exec "$1<> $MakeFIFO_file" 2>"/dev/null" || break
        MakeFIFO_success="true"
    done
    rm -rf "${MakeFIFO_directory:-}"
    unset  "MakeFIFO_directory"
    eval trap -- "$MakeFIFO_handler" EXIT
    unset  "MakeFIFO_handler"
    "$MakeFIFO_success" || { echo "$FUNCNAME: $1: Could not create FIFO" >&2; return "1"; }
}

Powyższe funkcje można połączyć w jedną funkcję, która będzie działać w obu systemach operacyjnych. Poniżej znajduje się przykład takiej funkcji. Tutaj podjęto próbę stworzenia prawdziwie anonimowego FIFO. Jeśli się to nie powiedzie, wówczas nazwany FIFO zostanie utworzony i przekształcony w anonimowy FIFO.

MakeFIFO() {
    MakeFIFO.SetStatus() {
        return "${1:-$?}"
    }
    MakeFIFO.CleanUp() {
        local "MakeFIFO_status=$?"
        rm -rf "${MakeFIFO_directory:-}"    
        unset "MakeFIFO_directory"
        MakeFIFO.SetStatus "$MakeFIFO_status" && true
        eval eval "${MakeFIFO_handler:-:}'; true'" 
    }
    local "MakeFIFO_success=false" "MakeFIFO_upper=$(ulimit -n)" "MakeFIFO_file=" 
    MakeFIFO_handler="$(trap -p EXIT)"
    MakeFIFO_handler="${MakeFIFO_handler#trap -- }"
    MakeFIFO_handler="${MakeFIFO_handler% *}"
    trap -- 'MakeFIFO.CleanUp' EXIT
    until "$MakeFIFO_success"; do
        [[ $# -eq 1 && ${#1} -le ${#MakeFIFO_upper} && -z ${1%%[0-9]*}
        && 10#$1 -gt 2 && 10#$1 -lt MakeFIFO_upper ]] || break
        if eval ! exec "$1<> " <(:) 2>"/dev/null"; then
            MakeFIFO_directory=$(mktemp -d) 2>"/dev/null" || break
            MakeFIFO_file="$MakeFIFO_directory/pipe"
            mkfifo -m 600 $MakeFIFO_file 2>"/dev/null" || break
            ! eval ! exec "$1<> $MakeFIFO_file" 2>"/dev/null" || break
        fi
        MakeFIFO_success="true"
    done
    rm -rf "${MakeFIFO_directory:-}"
    unset  "MakeFIFO_directory"
    eval trap -- "$MakeFIFO_handler" EXIT
    unset  "MakeFIFO_handler"
    "$MakeFIFO_success" || { echo "$FUNCNAME: $1: Could not create FIFO" >&2; return "1"; }
}

Oto przykład tworzenia anonimowego FIFO, a następnie pisania tekstu do tego samego FIFO.

fd="6"
MakeFIFO "$fd"
echo "Now is the" >&"$fd"
echo "time for all" >&"$fd"
echo "good men" >&"$fd"

Poniżej znajduje się przykład czytania całej zawartości anonimowego FIFO.

echo "EOF" >&"$fd"
while read -u "$fd" message; do
    [[ $message != *EOF ]] || break
    echo "$message"
done

Daje to następujący wynik.

Now is the
time for all
good men

Poniższe polecenie zamyka anonimowy FIFO.

eval exec "$fd>&-"

Odnośniki:
Tworzenie anonimowego potoku do późniejszego wykorzystania
Pliki w publicznie zapisywanych katalogach są niebezpiecznym
zabezpieczeniem skryptów powłoki

Korzystając ze świetnej i jasnej odpowiedzi od htamów, zmodyfikowałem ją trochę, aby użyć jej w jednej linijce, oto ona:

# create a temporary named pipe
PIPE=(`(exec 0</dev/null 1</dev/null; (( read -d \  e < /proc/self/stat ; echo $e >&2 ; exec tail -f /dev/null 2> /dev/null ) | ( read -d \  e < /proc/self/stat ; echo $e  >&2 ; exec tail -f /dev/null 2> /dev/null )) &) 2>&1 | for ((i=0; i<2; i++)); do read e; printf "$e "; done`)
# attach it to file descriptors 3 and 4
exec 3>/proc/${PIPE[0]}/fd/1 4</proc/${PIPE[1]}/fd/0
...
# kill the temporary pids
kill ${PIPE[@]}
...
# anything we write to fd 3 can be read back from fd 4
echo 'Hello world!' >&3
head -n1 <&4
...
# close the file descriptor when we are finished (optional)
exec 3>&- 4<&-