hak zamykający bash; lub zabicie wszystkich procesów w tle, gdy główny proces ginie

Question

Mam bash, który uruchamia niekończące polecenia jako procesów w tle:

#!/bin/bash 

function xyz() { 
    # some awk command 
} 

endlesscommand "param 1" | xyz & # async 
pids=$! 
endlesscommand "param 2" | xyz & # async 
pids="$pids "$! 
endlesscommand "param 3" | xyz # sync so the script doesn't leave 

Jedynym sposobem, aby zatrzymać tego skryptu jest (musi być) Ctrl-C lub zabić i kiedy to się stanie, muszę zabić wszystkie procesy w tle wymienione w zmiennej $ pids. Jak to zrobić?

Gdyby to było możliwe, aby złapać sygnał kill na głównego procesu i wykonania funkcji, gdy tak się dzieje (hak zamykania), chciałbym zrobić coś takiego:

for $pid in $pids; do kill $pid; done; 

Ale nie mogę znaleźć sposobu to zrobić ...

---

ROZWIĄZANIE z następujących stanowisk:

#!/bin/bash 

function xyz() { 
# some awk command 
} 

trap 'jobs -p | xargs kill' EXIT # part of the solution 

endlesscommand "param 1" | xyz & # async 
endlesscommand "param 2" | xyz & # async 
endlesscommand "param 3" | xyz & # don't sync, but wait: 

# other part of the solution: 
while pgrep -P "$BASHPID" > /dev/null; do 
    wait 
done 

Answer 1

Oto pułapka że nie trzeba śledzić pids:

trap 'jobs -p | xargs kill' EXIT 

EDIT: @Barmar pytanie, czy działa to w skryptach niezasilanych, w których kontrola pracy zwykle nie jest dostępna. To robi. Rozważmy następujący scenariusz:

$ cat no-job-control 
#! /bin/bash 

set -e -o pipefail 

# Prove job control is off 
if suspend 
then 
    echo suspended 
else 
    echo suspension failed, job control must be off 
fi 

echo 

# Set up the trap 
trap 'jobs -p | xargs kill' EXIT 

# Make some work 
(echo '=> Starting 0'; sleep 5; echo '=> Finishing 0') & 
(echo '=> Starting 1'; sleep 5; echo '=> Finishing 1') & 
(echo '=> Starting 2'; sleep 5; echo '=> Finishing 2') & 

echo "What's in jobs -p?" 
echo 

jobs -p 

echo 
echo "Ok, exiting now" 
echo 

Po uruchomieniu widzimy PID trzech grup liderów, a następnie zobaczyć je zabity:

$ ./no-job-control 
./no-job-control: line 6: suspend: cannot suspend: no job control 
suspension failed, job control must be off 

=> Starting 0 
What's in jobs -p? 
=> Starting 1 

54098 
54099 
54100 

Ok, exiting now 

=> Starting 2 
./no-job-control: line 31: 54098 Terminated: 15   (echo '=> Starting 0'; sleep 5; echo '=> Finishing 0') 
./no-job-control: line 31: 54099 Terminated: 15   (echo '=> Starting 1'; sleep 5; echo '=> Finishing 1') 
./no-job-control: line 31: 54100 Terminated: 15   (echo '=> Starting 2'; sleep 5; echo '=> Finishing 2') 

Gdybyśmy zamiast zakomentuj trap linii i ponownie metę trzy zadania nie umierają, a kilka sekund później wydrukują ostatnie wiadomości. Zauważ zwrócony wiersz z przeplotem z końcowymi wyjściami.

$ ./no-job-control 
./no-job-control: line 6: suspend: cannot suspend: no job control 
suspension failed, job control must be off 

=> Starting 0 
What's in jobs -p? 

54110 
54111 
54112 
=> Starting 1 

Ok, exiting now 

=> Starting 2 
$ => Finishing 0 
=> Finishing 2 
=> Finishing 1 

Answer 2

kill `ps axl | grep "endlesscommand" | awk '{printf $4" "}'` 

to będzie wyglądać dla procesów nadrzędnych, które ma wpływ na "endlesscommand"

Answer 3

Można użyć funkcji pgrep i funkcji do zabicia wszystkich procesów utworzonych w ramach głównego procesu, takiego jak ten. To nie tylko zabiłoby bezpośrednie procesy potomne, ale także te stworzone pod nim.

#!/bin/bash 

function killchildren { 
    local LIST=() IFS=$'\n' A 
    read -a LIST -d '' < <(exec pgrep -P "$1") 
    local A SIGNAL="${2:-SIGTERM}" 
    for A in "${LIST[@]}"; do 
     killchildren_ "$A" "$SIGNAL" 
    done 
} 

function killchildren_ { 
    local LIST=() 
    read -a LIST -d '' < <(exec pgrep -P "$1") 
    kill -s "$2" "$1" 
    if [[ ${#LIST[@]} -gt 0 ]]; then 
     local A 
     for A in "${LIST[@]}"; do 
      killchildren_ "$A" "$2" 
     done 
    fi 
} 

trap 'killchildren "$BASHPID"' EXIT 

endlesscommand "param 1" & 
endlesscommand "param 2" & 
endlesscommand "param 3" & 

while pgrep -P "$BASHPID" >/dev/null; do 
    wait 
done 

Co do oryginalnego kodu, byłoby lepiej po prostu korzystać z tablic, a także nie trzeba użyć pętli for:

#!/bin/bash 

trap 'kill "${pids[@]}"' EXIT 

pids=() 
endlesscommand "param 1" & # async 
pids+=("$!") 
endlesscommand "param 2" & # async 
pids+=("$!") 
endlesscommand "param 3" & # syncing this is not a good idea since if the main process would end along with it if it ends earlier. 
pids+=("$!") 

while pgrep -P "$BASHPID" >/dev/null; do 
    wait 
done 

Oryginalny numer funkcja: http://www.linuxquestions.org/questions/blog/konsolebox-210384/bash-functions-to-list-and-kill-or-send-signals-to-process-trees-34624/