Attente des processus Linux

Introduction

Les processus Linux sont des composants fondamentaux du système d'exploitation qui exécutent des programmes et effectuent des tâches. Lors du développement de scripts shell, il est souvent nécessaire d'exécuter plusieurs processus simultanément et de s'assurer qu'ils se terminent avant de poursuivre les opérations suivantes.

Dans ce laboratoire (LabEx), vous allez apprendre à utiliser la commande wait dans les scripts shell Linux. Cet outil puissant permet aux processus parents de suspendre leur exécution jusqu'à ce que leurs processus enfants en arrière-plan soient terminés. En maîtrisant les techniques d'attente de processus, vous pouvez créer des scripts plus efficaces qui coordonnent correctement plusieurs opérations simultanées.

Comprendre l'attente de processus est essentiel pour l'administration système, l'automatisation et le développement de scripts shell robustes. Vous allez apprendre à démarrer des processus en arrière-plan, à attendre leur terminaison et à gérer leurs codes de sortie pour garantir un flux d'exécution fiable.

Comprendre les processus Linux et l'exécution en arrière-plan

Dans cette étape, vous allez apprendre à connaître les processus Linux et à exécuter des commandes en arrière-plan en utilisant l'opérateur &.

Qu'est-ce qu'un processus Linux ?

Un processus sous Linux est une instance d'un programme en cours d'exécution. Chaque processus a un identifiant de processus (Process ID - PID) unique et s'exécute indépendamment des autres processus. Lorsque vous exécutez une commande dans le terminal, vous démarrez un processus.

Exécution de processus en arrière-plan

Normalement, lorsque vous exécutez une commande dans le terminal, vous devez attendre qu'elle se termine avant de pouvoir exécuter une autre commande. Cependant, vous pouvez exécuter une commande en arrière-plan en ajoutant un astérisque & à la fin de la commande.

Essayons cela :

Accédez au répertoire de votre projet :
```
cd ~/project
```
Créez un simple script qui simule une tâche longue :
```
nano long_task.sh
```

Ajoutez le contenu suivant au script :

#!/bin/bash
echo "Starting long task with PID $$"
sleep 5
echo "Long task completed"

Enregistrez le fichier en appuyant sur Ctrl+O, puis Entrée, et quittez avec Ctrl+X.
Rendez le script exécutable :
```
chmod +x long_task.sh
```
Exécutez le script normalement :
```
./long_task.sh
```
Vous verrez une sortie comme celle-ci :
```
Starting long task with PID 1234
Long task completed
```
Notez que vous avez dû attendre que le script se termine avant de récupérer votre invite de commande.
Maintenant, exécutez le script en arrière-plan :
```
./long_task.sh &
```
Vous verrez une sortie comme celle-ci :
```
[1] 1235
Starting long task with PID 1235
```
Le [1] est le numéro de tâche (job number), et 1235 est le PID. Notez que vous récupérez immédiatement votre invite de commande.
Après environ 5 secondes, vous verrez :
```
Long task completed
[1]+  Done                    ./long_task.sh
```
Cela indique que le processus en arrière-plan s'est terminé.

Lorsque vous exécutez une commande en arrière-plan, le shell n'attend pas qu'elle se termine avant de vous permettre d'entrer d'autres commandes. Cela est utile pour exécuter plusieurs tâches simultanément.

Utilisation de la commande wait pour synchroniser les processus

Dans cette étape, vous allez apprendre à utiliser la commande wait pour synchroniser les processus, en faisant attendre le processus parent jusqu'à la fin des processus en arrière-plan.

Qu'est-ce que la commande wait ?

La commande wait est utilisée dans les scripts shell pour suspendre l'exécution du script jusqu'à ce qu'un ou plusieurs processus en arrière-plan se soient terminés. Cela est particulièrement utile lorsque vous devez vous assurer que certaines tâches sont terminées avant de poursuivre les opérations suivantes.

Utilisation de wait sans arguments

Lorsqu'elle est utilisée sans arguments, la commande wait attend que tous les processus en arrière-plan se terminent.

Créons un script qui illustre cela :

Accédez au répertoire de votre projet :
```
cd ~/project
```
Créez un nouveau script :
```
nano wait_demo.sh
```

Ajoutez le contenu suivant au script :

#!/bin/bash

echo "Starting background tasks..."

## Start two background tasks
./long_task.sh &
./long_task.sh &

echo "Waiting for all background tasks to complete..."
wait
echo "All background tasks have completed!"

Enregistrez et quittez l'éditeur en appuyant sur Ctrl+O, puis Entrée, et enfin Ctrl+X.
Rendez le script exécutable :
```
chmod +x wait_demo.sh
```

Exécutez le script :

./wait_demo.sh

Vous verrez une sortie similaire à :

Starting background tasks...
Starting long task with PID 1236
Starting long task with PID 1237
Waiting for all background tasks to complete...
Long task completed
Long task completed
All background tasks have completed!

Notez que le message "All background tasks have completed!" n'apparaît que après que les deux longues tâches se sont terminées. Cela montre comment la commande wait suspend le script jusqu'à ce que tous les processus en arrière-plan se terminent.

Utilisation de wait avec un PID spécifique

Vous pouvez également utiliser wait pour attendre qu'un processus spécifique se termine en fournissant son PID :

Créez un autre script :
```
nano wait_pid_demo.sh
```

Ajoutez le contenu suivant :

#!/bin/bash

echo "Starting background tasks..."

## Start two background tasks and capture their PIDs
./long_task.sh &
pid1=$!

./long_task.sh &
pid2=$!

echo "First process PID: $pid1"
echo "Second process PID: $pid2"

echo "Waiting for the first task to complete..."
wait $pid1
echo "First task has completed!"

echo "Waiting for the second task to complete..."
wait $pid2
echo "Second task has completed!"

Enregistrez et quittez l'éditeur en appuyant sur Ctrl+O, puis Entrée, et enfin Ctrl+X.
Rendez le script exécutable :
```
chmod +x wait_pid_demo.sh
```
Exécutez le script :
```
./wait_pid_demo.sh
```
La sortie montrera que le script attend chaque processus individuellement.

La variable $! contient le PID du dernier processus en arrière-plan exécuté. Cela vous permet de capturer et d'utiliser ultérieurement le PID avec la commande wait.

Gestion du statut de retour de wait

Dans cette étape, vous allez apprendre à capturer et à gérer le statut de retour de la commande wait, qui reflète le statut de sortie des processus en arrière-plan.

Comprendre le statut de sortie et de retour

Sous Linux, chaque commande retourne un statut de sortie lorsqu'elle se termine. Un statut de sortie égal à 0 indique généralement un succès, tandis qu'une valeur non nulle indique une erreur ou une forme d'échec.

La commande wait retourne le statut de sortie de la commande attendue. Si plusieurs processus sont attendus, elle retourne le statut de sortie du dernier processus qui s'est terminé.

Créons des scripts pour illustrer cela :

Accédez au répertoire de votre projet :
```
cd ~/project
```
Créez un script qui réussit :
```
nano success_task.sh
```

Ajoutez le contenu suivant :

#!/bin/bash
echo "Starting success task"
sleep 2
echo "Success task completed successfully"
exit 0 ## Exit with success status

Enregistrez et quittez en appuyant sur Ctrl+O, puis Entrée, et enfin Ctrl+X. Puis rendez-le exécutable :
```
chmod +x success_task.sh
```
Créez un script qui échoue :
```
nano fail_task.sh
```

Ajoutez le contenu suivant :

#!/bin/bash
echo "Starting fail task"
sleep 3
echo "Fail task encountered an error"
exit 1 ## Exit with error status

Enregistrez et quittez en appuyant sur Ctrl+O, puis Entrée, et enfin Ctrl+X. Puis rendez-le exécutable :
```
chmod +x fail_task.sh
```
Maintenant, créez un script qui capture le statut de wait :
```
nano wait_status_demo.sh
```

Ajoutez le contenu suivant :

#!/bin/bash

echo "Running a successful background task..."
./success_task.sh &
wait

wait_status=$?
echo "Wait returned with status: $wait_status"

if [ $wait_status -eq 0 ]; then
  echo "The background task succeeded!"
else
  echo "The background task failed with status: $wait_status"
fi

echo ""
echo "Running a failing background task..."
./fail_task.sh &
wait

wait_status=$?
echo "Wait returned with status: $wait_status"

if [ $wait_status -eq 0 ]; then
  echo "The background task succeeded!"
else
  echo "The background task failed with status: $wait_status"
fi

Enregistrez et quittez en appuyant sur Ctrl+O, puis Entrée, et enfin Ctrl+X. Puis rendez-le exécutable :
```
chmod +x wait_status_demo.sh
```

Exécutez le script :

./wait_status_demo.sh

Vous verrez une sortie similaire à :

Running a successful background task...
Starting success task
Success task completed successfully
Wait returned with status: 0
The background task succeeded!

Running a failing background task...
Starting fail task
Fail task encountered an error
Wait returned with status: 1
The background task failed with status: 1

Cela montre comment vous pouvez utiliser le statut de retour de la commande wait pour déterminer si les processus en arrière-plan se sont terminés avec succès ou non, ce qui est essentiel pour la gestion des erreurs dans les scripts shell.

Réalisation d'une application pratique

Dans cette étape finale, vous allez appliquer ce que vous avez appris pour créer un script plus complexe qui simule un processus de préparation de système. Ce script coordonnera plusieurs tâches en arrière-plan et s'assurera qu'elles se terminent toutes avec succès avant de poursuivre.

Création des scripts de préparation

Tout d'abord, nous allons créer deux scripts qui simulent différentes tâches de préparation :

Accédez au répertoire de votre projet :
```
cd ~/project
```
Créez le premier script de préparation :
```
nano decorate_hall.sh
```

Ajoutez le contenu suivant :

#!/bin/bash
echo "Decorating the hall..."
sleep 3
echo "Hanging decorations..."
sleep 2
echo "Decoration complete."
exit 0

Enregistrez et quittez en appuyant sur Ctrl+O, puis Entrée, et enfin Ctrl+X. Puis rendez-le exécutable :
```
chmod +x decorate_hall.sh
```
Créez le deuxième script de préparation :
```
nano cook_feast.sh
```

Ajoutez le contenu suivant :

#!/bin/bash
echo "Preparing ingredients..."
sleep 2
echo "Cooking main dishes..."
sleep 3
echo "Preparing desserts..."
sleep 1
echo "Cooking complete."
exit 0

Enregistrez et quittez en appuyant sur Ctrl+O, puis Entrée, et enfin Ctrl+X. Puis rendez-le exécutable :
```
chmod +x cook_feast.sh
```

Création du script principal de coordination

Maintenant, créons le script principal qui coordonnera ces tâches de préparation :

Créez le script principal :
```
nano prepare_feast.sh
```

Ajoutez le contenu suivant :

#!/bin/bash

echo "=== Preparation Ceremony Started ==="
echo "Starting all preparation tasks..."

## Start the preparations in the background
./decorate_hall.sh &
decoration_pid=$!

./cook_feast.sh &
cooking_pid=$!

echo "All tasks started. Waiting for completion..."

## Wait for decoration to finish
wait $decoration_pid
decoration_status=$?

if [ $decoration_status -eq 0 ]; then
  echo "Decoration completed successfully."
else
  echo "Error: Decoration failed with status $decoration_status"
  exit 1
fi

## Wait for cooking to finish
wait $cooking_pid
cooking_status=$?

if [ $cooking_status -eq 0 ]; then
  echo "Cooking completed successfully."
else
  echo "Error: Cooking failed with status $cooking_status"
  exit 1
fi

## All preparations completed successfully
echo "=== All preparations completed successfully! ==="
echo "The ceremony can now begin."

## Create a verification file to indicate successful completion
echo "decoration_status=$decoration_status" > preparation_results.txt
echo "cooking_status=$cooking_status" >> preparation_results.txt
echo "overall_status=0" >> preparation_results.txt

exit 0

Enregistrez et quittez en appuyant sur Ctrl+O, puis Entrée, et enfin Ctrl+X. Puis rendez-le exécutable :
```
chmod +x prepare_feast.sh
```
Exécutez le script principal :
```
./prepare_feast.sh
```
Vous verrez la sortie de toutes les tâches de préparation s'exécutant en parallèle, et le script principal attendra que chaque tâche se termine avant de déclarer le succès global.

Compréhension du script

Examinons les parties clés du script principal :

Nous démarrons chaque tâche de préparation en arrière-plan en utilisant &
Nous capturons le PID de chaque tâche en utilisant $!
Nous attendons que chaque tâche se termine en utilisant wait $pid
Nous vérifions le statut de sortie de chaque tâche
Nous créons un fichier de vérification avec les résultats

Cette approche nous permet de :

Exécuter plusieurs tâches en parallèle
Surveiller le succès/échec de chaque tâche
Arrêter le processus global si une tâche individuelle échoue
Créer un enregistrement des résultats

C'est un modèle courant dans l'administration système et les scripts d'automatisation, où plusieurs processus doivent être coordonnés et surveillés.

Résumé

Dans ce laboratoire, vous avez appris à gérer et synchroniser efficacement les processus sous Linux en utilisant la commande wait. Cette compétence essentielle vous permet de créer des scripts shell plus sophistiqués capables de coordonner plusieurs opérations simultanées.

Les concepts clés que vous avez maîtrisés incluent :

L'exécution de processus en arrière-plan en utilisant l'opérateur &
L'utilisation de la commande wait pour suspendre l'exécution jusqu'à la fin des processus en arrière-plan
L'attente de processus spécifiques par leur PID
La capture et la gestion du statut de retour de la commande wait
La mise en œuvre de la gestion des erreurs pour les processus en arrière-plan
La coordination de plusieurs tâches simultanées dans un scénario pratique

Ces compétences sont fondamentales pour l'administration système, l'automatisation et la programmation de scripts shell dans les environnements Linux. En gérant correctement la synchronisation des processus, vous pouvez créer des scripts plus efficaces qui exploitent la concurrence tout en maintenant la séquence appropriée des opérations dépendantes.

Que vous développiez des systèmes de construction, des scripts de déploiement ou des outils d'administration système, la capacité à coordonner plusieurs processus est une compétence essentielle qui vous permettra de créer des solutions plus puissantes et plus efficaces.