Pesquisando processos paralelos usando bash

Introdução:

Aqui está um script que criei que pesquisa processos em segundo plano no bash para um dos meus projetos que não apenas espera que todos os processos sejam concluídos usando a “espera” padrão, mas também mantém controle do tempo gasto para a conclusão, certifique-se de não pesquisar o concluídos e, finalmente, retornar o número de processos com falha.

Então aqui está e eu realmente aprecio qualquer feedback!

Idéia:

A função obtém uma lista de PIDs e um intervalo de pesquisa em segundos. À medida que o intervalo passa cada vez que um sinal de eliminação é enviado apenas para os processos em execução no momento. Um código de saída diferente de zero indica que o processo não está mais ativo – o que significa que foi concluído com êxito ou falhou. Nesse momento, aguardando aquele PID, o código de saída do processo é obtido. Isso ajuda a controlar a contagem com falha.

#!/bin/sh

STIME=$(date '+%s')

#Poll parallel running processes
#param 1: list of pid's (space delimited)
#param 2: polling interval (secs)
#return value: integer (number of failed processes)
function poll {
        local etime=
        local elapsed_sec=
        local fail=0
        local running_pid_list=$1
        local interval=$2
        while sleep $interval
        do
                poll_pid_list=$running_pid_list
                if [[ -n $poll_pid_list ]]
                then
                        echo "polling $poll_pid_list"
                        running_pid_list=
                        for pid in $poll_pid_list
                        do
                                kill -0 $pid 2>/dev/null
                                if [ $? -ne 0 ]
                                then
                                        wait $pid
                                        if [[ $? -ne 0 ]]
                                        then
                                                ((fail++))
                                        else
                                                etime=$(date '+%s')
                                                elapsed_sec=$((etime - STIME))
                                                echo $pid completed after $elapsed_sec seconds at $etime 
                                        fi
                                else
                                        running_pid_list="$running_pid_list $pid"
                                fi
                        done
                else
                        break
                fi
        done
        return $fail
}

#Execute process in parallel as background processes
pid_list=
poll_interval=2

# Process 1
sleep 5 &
pid_list="$pid_list $!"
# Process 2
sleep 10 &
pid_list="$pid_list $!"

poll "$pid_list" $poll_interval
echo "Number of failed processes:$?" 

No script acima, estou executando dois processos (suspensão) em paralelo com um intervalo de pesquisa definido de 2 segundos. No meu projeto, na verdade, escrevo as estatísticas em um arquivo (não mostrado acima) em um formato que posso ler mais tarde usando “awk” e é um mecanismo de registro muito útil.

Boa votação!