Давши дві фонові команди, закінчіть решту, коли будь-яка програма виходить

У мене простий скрипт bash, який запускає два сервери:

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

Якщо друга команда завершиться, здається, що перша команда продовжує працювати.

Як я можу змінити це так, що якщо будь-яка команда закінчується, інша припиняється?

Зауважте, що нам не потрібно перевіряти рівні помилок фонових процесів, лише чи не відбулися вони.

Це запускає обидва процеси, чекає першого, який закінчиться, а потім вбиває іншого:

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

Як це працює

1. Початок:

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

   Вищеописані дві команди запускають обидва процеси у фоновому режимі.

2. Зачекайте

   wait -n

   Це очікує припинення будь-якого фонового завдання.

   Через -nопцію для цього потрібен bash 4.3 або вище.

3. Убити

   pkill -P $$

   Це вбиває будь-яку роботу, для якої поточний процес є батьківським. Іншими словами, це вбиває будь-який фоновий процес, який ще триває.

   Якщо у вашій системі немає pkill, спробуйте замінити цей рядок на:

   kill 0

   що також вбиває поточну групу процесу .

Легко перевіряється приклад

Змінивши скрипт, ми можемо перевірити його навіть без gulpвстановленого:

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

Вищеописаний сценарій можна запустити як, bash script.sh 1 3і перший процес закінчується першим. Крім того, можна запустити його як bash script.sh 3 1і другий процес закінчиться перший. В будь-якому випадку видно, що це працює за бажанням.

Це хитро. Ось що я створив; можливо можливо спростити / упорядкувати його:

#!/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

• По-перше, запустіть процес ( while true; do sleep 42; done &), який спає / призупиняється назавжди. Якщо ви впевнені, що ваші дві команди припиняться протягом певного часу (наприклад, за годину), ви можете змінити це на один сон, який перевищить цей (наприклад, sleep 3600). Потім ви можете змінити таку логіку, щоб використовувати це як тайм-аут; тобто вбийте процеси, якщо вони все ще працюють через стільки часу. (Зауважте, що вищезазначений сценарій цього не робить.)
• Запустіть два асинхронні (паралельні фонові) процеси.
  • Вам не потрібно ./для cd.
  • command & echo "$!" > somewhere; wait "$!" - хитра конструкція, яка запускає процес асинхронно, фіксує його PID, а потім чекає його; що робить його начебто переднього (синхронного) процесу. Але це відбувається в (…)списку, який знаходиться у фоновому режимі в повному обсязі, тому gulpпроцеси протікають асинхронно.
  • Після завершення будь-якого з gulpпроцесів запишіть його статус у тимчасовий файл і вкажіть процес "вічно сплячого".
• sleep 1 для захисту від перегонових умов, коли перший фоновий процес гине, перш ніж другий отримує можливість записати свій PID у файл.
• Зачекайте, коли процес "вічно спить" завершиться. Це відбувається після завершення будь- якого з gulpпроцесів, як зазначено вище.
• Подивіться, який фоновий процес завершився. Якщо це не вдалося, вбийте іншого.
• Якщо один процес не вдався, а ми вбили іншого, дочекайтеся завершення другого і збережіть його статус у файлі. Якщо перший процес закінчився успішно, дочекайтеся закінчення другого.
• Перевірте статуси двох процесів.

Для повноти ось що я в кінцевому підсумку використав:

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

Це працює для мене на 64-розрядному Git для Windows 2.5.3. Старіші версії можуть не приймати цю -nопцію wait.

У моїй системі (Centos) waitнемає, -nтому я це зробив:

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

Це не чекає "жодного", а чекає першого. Але все-таки це може допомогти, якщо ви знаєте, який сервер буде зупинений першим.