BASH: redirect stdin to variable number of subprocesses

As the title says, I would like to redirect stdin to a variable number of output subprocesses.

If I had to redirect to output files I could do something like

files=(file_1 file_2 ... file_n)
tee ${files[*]} >/dev/null

but with subprocesses (using process substitutions, specifically), doing things like

programs=(">(exe_1 args_1)" ... ">(exe_n args_n)")
tee ${programs[@]} >/dev/null

will not intepret the >() as process substitutions but as literal filenames (for security reasons, I assume); also, the flags withing the substitutions are interpreted as flags of tee.

Is it possible to read ONE LINE from stdin and redirect it to all these processes (which, again, are variable in number: n is unknown)? Have I missed something, somewhere?

Thanks in advance and sorry for my bad English.

Instead of using process substitution, create a bunch of named pipes in a loop, and run each process with its stdin redirected to one of the pipes. Then use tee to write to all the pipes.

progs=(exe_1 exe_2 ...)
args=(args_1 args2 ...)
pipes=()
arraylenth=${#progs[@]}

for (( i=0; i<${arraylength}; i++ ))
do
    pipe=/tmp/pipe.$$.$i
    mkfifo "$pipe" && pipes+=("$pipe") && "$progs[i]" "$args[i]" < "$pipe" &
done

tee "${pipes[@]" > /dev/null
# Clean up
rm -f "${pipes[@]"

This solution has each program run with exactly 1 argument. It's hard to make it more general robustly because bash doesn't have 2-dimensional arrays.

Unfortunately, this is a job for eval. Given something like:

all_redirections=""

add_redirection() {
  local argv_q
  printf -v argv_q '%q ' "$@"       # generate an eval-safe escaping of "$@"
  all_redirections+=" ${argv_q} "   # append that to all_redirections string
}

to_all_redirections() { eval "tee ${all_redirections}" >/dev/null; }

...you can run:

add_redirection exe_1 arg_1_a arg_1_b
add_redirection exe_2 arg_2_a
# ...
add_redirection exe_n arg_n

...and then, when you have a program whose output is to be copied to the input of those executables:

yourprogram | to_all_redirections

This Shellcheck-clean code doesn't use eval and can handle any number of programs with any number of arguments:

#! /bin/bash -p

prog_args=( ::: sed -e 's/^/[1] /'
            ::: sed -e 's/^/[2] /'
            ::: sed -e 's/^/[3] /'  )

exec 3>&1

function tee_to_progs
{
    (( $# < 2 )) && return 1

    local -r startstr=$1
    shift

    local pargs=()
    while [[ $# -gt 0 && $1 != "$startstr" ]]; do
        pargs+=( "$1" )
        shift
    done

    if (( $# == 0 )); then
        # Last program to run.  It can just read stdin and write stdout.
        "${pargs[@]}"
    else
        tee >("${pargs[@]}" >&3) | tee_to_progs "$@"
    fi
}

tee_to_progs "${prog_args[@]}"

• The prog_args array holds the programs and arguments to be run. Since Bash doesn't support nested arrays each command is preceded by a marker string to enable the separate programs and arguments to be identified. I used the string ::: (because it is used for a similar purpose in GNU Parallel), but any string that isn't used as a program name or argument could be used instead. The code assumes that the first string (whatever it happens to be) in the array is the marker string, so the code doesn't need to be changed if the string is changed. I tested using _ instead of :::.
• The sed commands are just examples. I used them for testing because the outputs of each program can be easily identified.
• Note that this code only supports running simple commands. If you need to run other commands (e.g. ones that use redirections) you will need to use a different approach (probably involving the dreaded eval).
• exec 3>&1 causes file descriptor number 3 to be associated with standard output. It is used in the code to ensure that output goes to the "real" standard output.
• The tee_to_progs function runs the first program in its list of arguments with input duplicated to it with tee and pipes the tee output to a recursive call of the function that does the same for the second and subsequent programs.

GNU Parallel has --tee for this:

cat input | parallel --tee --pipe my_program {} ::: arg1 arg2 arg3

Internally it works very much like Barmar's solution, but you get GNU Parallel's output control:

• the output is serialized, so output from two jobs is not mixed
• you can keep the order --keep-order
• you can --tag each line

and clean up of temporary files is done before the job is done, so you do not need to clean up temporary files if the script is killed.

E.g.

seq 10000 | parallel --tee --pipe --tag --keep-order grep {} ::: {1..9}