Scripting Bash : Utilisation de la commande Trap pour la gestion des signaux

Introduction

Dans cet atelier, nous allons explorer la commande trap dans le cadre du scripting Bash. La commande trap est un outil puissant qui vous permet de capturer et de gérer les signaux, les interruptions et les entrées utilisateur au sein de vos scripts. En utilisant trap, vous pouvez définir des actions spécifiques à exécuter lorsque des signaux particuliers sont reçus, ce qui vous permet de maîtriser les comportements imprévisibles et de gérer proprement diverses situations. Cet atelier est conçu pour les débutants et vous guidera pas à pas dans l'utilisation efficace de la commande trap.

Créer un script Bash

Commençons par créer un nouveau fichier de script Bash dans lequel nous implémenterons la commande trap.

Ouvrez un terminal dans l'interface WebIDE. Vous devriez voir une invite de commande se terminant par le symbole $.
Naviguez vers le répertoire du projet :
```
cd ~/project
```
Cette commande change votre répertoire de travail actuel pour /home/labex/project.
Créez un nouveau fichier nommé trap_example.sh :
```
touch trap_example.sh
```
La commande touch crée un fichier vide s'il n'existe pas, ou met à jour sa date de modification s'il existe déjà.
Ouvrez le fichier trap_example.sh dans l'éditeur de la WebIDE. Vous pouvez le faire en cliquant sur le nom du fichier dans l'explorateur de fichiers situé sur le côté gauche de l'interface.

Implémenter une commande Trap de base

À présent, implémentons une commande trap simple dans notre script pour capturer des signaux spécifiques et quitter le programme proprement.

Ajoutez le contenu suivant au fichier trap_example.sh :
```
#!/bin/bash

cleanup_and_exit() {
  echo -e "\nSignal received! Cleaning up and exiting..."
  exit 0
}

trap cleanup_and_exit SIGINT SIGTERM

echo "This script will run until you press Ctrl+C."
echo "Press Ctrl+C to see the trap in action and exit gracefully."

count=1
while true; do
  echo "Script is running... (iteration $count)"
  sleep 1
  ((count++))
done
```
Analysons ce script :
- La première ligne #!/bin/bash est appelée un "shebang". Elle indique au système que ce script doit être exécuté par le shell Bash.
- Nous définissons une fonction cleanup_and_exit qui affiche un message et interrompt le script.
- La commande trap est configurée pour appeler cleanup_and_exit lorsqu'elle intercepte les signaux SIGINT (interruption) ou SIGTERM (terminaison). Le signal SIGINT est généralement envoyé lorsque vous appuyez sur Ctrl+C, tandis que SIGTERM est souvent utilisé lorsqu'on demande à un processus de s'arrêter proprement.
- Les commandes echo affichent des instructions pour l'utilisateur.
- La boucle while s'exécute indéfiniment, affichant un message et incrémentant un compteur chaque seconde.
Enregistrez le fichier après avoir ajouté le contenu.

Rendre le script exécutable et le lancer

Avant de pouvoir exécuter notre script, nous devons lui donner les droits d'exécution. Cela indique au système que ce fichier est autorisé à être lancé comme un programme.

Dans le terminal, rendez le script exécutable :
```
chmod +x ~/project/trap_example.sh
```
La commande chmod modifie les permissions d'un fichier. L'option +x ajoute la permission d'exécution.
Lancez le script :
```
~/project/trap_example.sh
```
Cette commande demande à Bash d'exécuter notre script.
Le script va commencer à s'exécuter. Vous verrez les instructions s'afficher à l'écran. Laissez-le tourner quelques secondes.
Maintenant, appuyez sur Ctrl+C pour l'interrompre. Vous devriez voir le message "Signal received!" s'afficher avant que le script ne s'arrête. C'est notre "trap" en action !

Modifier le Trap pour utiliser une fonction complexe

Au lieu d'utiliser une fonction simpliste, modifions notre script pour utiliser une fonction plus élaborée avec la commande trap. Cela nous permet d'effectuer des actions plus détaillées lorsqu'un signal est reçu.

Ouvrez le fichier trap_example.sh dans l'éditeur de la WebIDE.
Remplacez le contenu du fichier par le suivant :
```
#!/bin/bash

cleanup_and_exit() {
  echo -e "\nSignal received! Cleaning up..."
  echo "Performing cleanup tasks..."
  ## Add any necessary cleanup code here
  echo "Cleanup completed."
  echo "Exiting script gracefully."
  exit 0
}

trap cleanup_and_exit SIGINT SIGTERM

echo "This script will run until you press Ctrl+C."
echo "Press Ctrl+C to see the trap function in action and exit gracefully."

count=1
while true; do
  echo "Script is running... (iteration $count)"
  sleep 1
  ((count++))
done
```
Examinons les changements :
- Nous avons enrichi la fonction cleanup_and_exit pour inclure des messages plus détaillés et un emplacement réservé pour d'éventuelles tâches de nettoyage.
- La fonction simule désormais un processus de nettoyage plus réaliste, qui pourrait inclure des tâches telles que la fermeture de descripteurs de fichiers, la suppression de fichiers temporaires ou la libération d'autres ressources.
- Nous avons mis à jour la boucle principale pour afficher un compteur d'itérations, ce qui permet de voir plus clairement que le script est actif.
Enregistrez le fichier après avoir effectué ces modifications.
Lancez à nouveau le script et testez-le en appuyant sur Ctrl+C :
```
~/project/trap_example.sh
```
Vous devriez voir les nouveaux messages de la fonction cleanup_and_exit lors de l'interruption du script, démontrant ainsi une sortie contrôlée et propre.

Résumé

Dans cet atelier, vous avez appris à utiliser la commande trap dans vos scripts Bash. Vous avez créé un script capable de capturer des signaux spécifiques et de définir des actions à entreprendre lors de la réception de ces signaux. Vous avez exploré différentes manières d'utiliser la commande trap, notamment avec des commandes en ligne et des fonctions dédiées.

La commande trap est un outil indispensable pour gérer les interruptions et effectuer des opérations de nettoyage dans vos scripts Bash. Elle vous permet de créer des applications en ligne de commande plus robustes et conviviales en gérant proprement les arrêts inattendus et les interruptions déclenchées par l'utilisateur.

N'oubliez pas que la capacité à gérer les signaux peut être cruciale dans de nombreux scénarios de scripting, comme garantir la suppression correcte des fichiers temporaires, fermer des connexions réseau ou sauvegarder l'état du programme avant qu'un script ne s'arrête de manière imprévue.