Biorąc pod uwagę dwa polecenia w tle, zakończ pozostałe po wyjściu z nich

Mam prosty skrypt bash, który uruchamia dwa serwery:

#!/bin/bash
(cd ./frontend && gulp serve) & (cd ./backend && gulp serve --verbose)

Jeśli drugie polecenie zakończy działanie, wydaje się, że pierwsze polecenie nadal działa.

Jak mogę to zmienić, aby jedno z poleceń zakończyło się, a drugie zostanie zakończone?

Pamiętaj, że nie musimy sprawdzać poziomów błędów procesów w tle, tylko czy zakończyły się.

To uruchamia oba procesy, czeka na pierwszy, który się kończy, a następnie zabija drugi:

#!/bin/bash
{ cd ./frontend && gulp serve; } &
{ cd ./backend && gulp serve --verbose; } &
wait -n
pkill -P $$

Jak to działa

1. Początek:

   { cd ./frontend && gulp serve; } &
   { cd ./backend && gulp serve --verbose; } &
   

   Powyższe dwa polecenia uruchamiają oba procesy w tle.

2. Czekać

   wait -n

   To czeka na zakończenie zadania w tle.

   Z powodu tej -nopcji wymaga to wersji bash 4.3 lub nowszej.

3. Zabić

   pkill -P $$

   To zabija każde zadanie, dla którego bieżący proces jest nadrzędny. Innymi słowy, zabija to cały działający proces w tle.

   Jeśli twój system nie ma pkill, spróbuj zastąpić ten wiersz:

   kill 0

   co również zabija bieżącą grupę procesów .

Łatwo testowalny przykład

Zmieniając skrypt, możemy go przetestować nawet bez gulpinstalacji:

$ cat script.sh 
#!/bin/bash
{ sleep $1; echo one;  } &
{ sleep $2; echo two;  } &
wait -n
pkill -P $$
echo done

Powyższy skrypt można uruchomić jako, bash script.sh 1 3a pierwszy proces kończy się jako pierwszy. Alternatywnie można uruchomić go jako, bash script.sh 3 1a drugi proces zakończy się jako pierwszy. W obu przypadkach widać, że działa to zgodnie z potrzebami.

To trudne. Oto, co wymyśliłem; możliwe jest uproszczenie / usprawnienie:

#!/bin/sh

pid1file=$(mktemp)
pid2file=$(mktemp)
stat1file=$(mktemp)
stat2file=$(mktemp)

while true; do sleep 42; done &
main_sleeper=$!

(cd frontend && gulp serve           & echo "$!" > "$pid1file";
    wait "$!" 2> /dev/null; echo "$?" > "$stat1file"; kill "$main_sleeper" 2> /dev/null) &
(cd backend  && gulp serve --verbose & echo "$!" > "$pid2file";
    wait "$!" 2> /dev/null; echo "$?" > "$stat2file"; kill "$main_sleeper" 2> /dev/null) &
sleep 1
wait "$main_sleeper" 2> /dev/null

if stat1=$(<"$stat1file")  &&  [ "$stat1" != "" ]  &&  [ "$stat1" != 0 ]
then
        echo "First process failed ..."
        if pid2=$(<"$pid2file")  &&  [ "$pid2" != "" ]
        then
                echo "... killing second process."
                kill "$pid2" 2> /dev/null
        fi
fi
if [ "$stat1" = "" ]  &&  \
   stat2=$(<"$stat2file")  &&  [ "$stat2" != "" ]  &&  [ "$stat2" != 0 ]
then
        echo "Second process failed ..."
        if pid1=$(<"$pid1file")  &&  [ "$pid1" != "" ]
        then
                echo "... killing first process."
                kill "$pid1" 2> /dev/null
        fi
fi

wait
if stat1=$(<"$stat1file")
then
        echo "Process 1 terminated with status $stat1."
else
        echo "Problem getting status of process 1."
fi
if stat2=$(<"$stat2file")
then
        echo "Process 2 terminated with status $stat2."
else
        echo "Problem getting status of process 2."
fi

• Najpierw uruchom proces ( while true; do sleep 42; done &), który śpi / zatrzymuje się na zawsze. Jeśli masz pewność, że twoje dwa polecenia zakończą się w określonym czasie (np. Godzinie), możesz zmienić to na pojedynczy sen, który go przekroczy (np sleep 3600.). Następnie możesz zmienić następującą logikę, aby użyć tego jako limitu czasu; tzn. zabij procesy, jeśli nadal działają po tak długim czasie. (Uwaga: powyższy skrypt obecnie tego nie robi).
• Uruchom dwa procesy asynchroniczne (współbieżne w tle).
  • Nie trzeba ./za cd.
  • command & echo "$!" > somewhere; wait "$!" jest trudną konstrukcją, która uruchamia proces asynchronicznie, przechwytuje swój PID, a następnie czeka na niego; dzięki czemu jest to rodzaj procesu pierwszego planu (synchronicznego). Ale dzieje się tak na (…)liście, która jest w całości w tle, więc gulpprocesy przebiegają asynchronicznie.
  • Po wyjściu jednego z gulpprocesów zapisz jego status do pliku tymczasowego i zabij proces „na zawsze”.
• sleep 1 aby zabezpieczyć się przed wyścigiem, w którym pierwszy proces w tle umiera, zanim drugi ma szansę zapisać swój PID w pliku.
• Poczekaj na zakończenie procesu „wiecznego snu”. Dzieje się tak po wyjściu jednego z gulpprocesów, jak wspomniano powyżej.
• Zobacz, który proces w tle został zakończony. Jeśli to się nie powiedzie, zabij drugiego.
• Jeśli jeden proces się nie powiedzie, a drugi zabijemy, poczekaj, aż drugi się zakończy i zapisze swój status w pliku. Jeśli pierwszy proces zakończy się pomyślnie, poczekaj na zakończenie drugiego.
• Sprawdź statusy dwóch procesów.

Dla kompletności oto, co skończyło się na użyciu:

#!/bin/bash
(cd frontend && gulp serve) &
(cd backend && gulp serve --verbose) &
wait -n
kill 0

Działa to dla mnie na Git dla Windows 2.5.3 64-bit. Starsze wersje mogą nie akceptować tej -nopcji wait.

W moim systemie (Centos), waitnie mam, -nwięc zrobiłem to:

{ sleep 3; echo one;  } &
FOO=$!
{ sleep 6; echo two;  } &
wait $FOO
pkill -P $$

To nie czeka na „jedno”, a raczej czeka na pierwsze. Ale nadal może pomóc, jeśli wiesz, który serwer zostanie zatrzymany jako pierwszy.