Étant donné deux commandes d'arrière-plan, mettez fin à la dernière lorsque l'une ou l'autre se ferme

J'ai un script bash simple qui démarre deux serveurs:

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

Si la deuxième commande se termine, il semble que la première commande continue de s'exécuter.

Comment puis-je changer cela de sorte que si l'une des commandes se termine, l'autre se termine?

Notez que nous n'avons pas besoin de vérifier les niveaux d'erreur des processus d'arrière-plan, juste s'ils se sont arrêtés.

Cela démarre les deux processus, attend le premier qui se termine puis tue l'autre:

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

Comment ça fonctionne

1. Début:

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

   Les deux commandes ci-dessus démarrent les deux processus en arrière-plan.

2. Attendez

   wait -n

   Cela attend la fin de l'un ou l'autre des travaux en arrière-plan.

   En raison de l' -noption, cela nécessite bash 4.3 ou mieux.

3. Tuer

   pkill -P $$

   Cela tue tout travail dont le processus actuel est le parent. En d'autres termes, cela tue tout processus d'arrière-plan toujours en cours d'exécution.

   Si votre système n'en a pas pkill, essayez de remplacer cette ligne par:

   kill 0

   ce qui tue également le groupe de processus actuel .

Exemple facilement testable

En changeant le script, nous pouvons le tester même sans gulpinstallé:

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

Le script ci-dessus peut être exécuté en tant que bash script.sh 1 3et le premier processus se termine en premier. Alternativement, on peut l'exécuter en tant que bash script.sh 3 1et le deuxième processus se terminera en premier. Dans les deux cas, on peut voir que cela fonctionne comme souhaité.

C'est délicat. Voici ce que j'ai imaginé; il peut être possible de le simplifier / rationaliser:

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

• Tout d'abord, démarrez un processus ( while true; do sleep 42; done &) qui s'endort / s'arrête pour toujours. Si vous êtes sûr que vos deux commandes se termineront dans un certain laps de temps (par exemple, une heure), vous pouvez changer cela en un seul sommeil qui dépassera cela (par exemple, sleep 3600). Vous pouvez ensuite modifier la logique suivante pour l'utiliser comme délai d'expiration; c'est-à-dire, tuez les processus s'ils sont toujours en cours d'exécution après ce temps. (Notez que le script ci-dessus ne fait actuellement pas cela.)
• Démarrez les deux processus asynchrones (arrière-plan simultané).
  • Vous n'avez pas besoin ./pour cd.
  • command & echo "$!" > somewhere; wait "$!" est une construction délicate qui démarre un processus de manière asynchrone, capture son PID, puis l'attend; ce qui en fait une sorte de processus de premier plan (synchrone). Mais cela se produit dans une (…)liste qui est en arrière-plan dans son intégralité, de sorte que les gulpprocessus s'exécutent de manière asynchrone.
  • Une fois l'un des gulpprocessus terminé, écrivez son état dans un fichier temporaire et supprimez le processus «toujours en sommeil».
• sleep 1 pour se protéger contre une condition de concurrence critique où le premier processus d'arrière-plan meurt avant que le second n'ait la possibilité d'écrire son PID dans le fichier.
• Attendez la fin du processus «toujours en sommeil». Cela se produit après la fin de l'un des gulpprocessus, comme indiqué ci-dessus.
• Voir le processus d'arrière-plan terminé. S'il échoue, tuez l'autre.
• Si un processus a échoué et que nous avons tué l'autre, attendez que le second se termine et enregistrez son état dans un fichier. Si le premier processus s'est terminé avec succès, attendez que le second se termine.
• Vérifiez les statuts des deux processus.

Pour être complet, voici ce que j'ai fini par utiliser:

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

Cela fonctionne pour moi sur Git pour Windows 2.5.3 64 bits. Les versions plus anciennes peuvent ne pas accepter l' -noption wait.

Sur mon système (Centos), waitn'a pas -ndonc j'ai fait ceci:

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

Cela n'attend pas "non plus", attend plutôt le premier. Mais cela peut toujours aider si vous savez quel serveur sera arrêté en premier.