Sortie du Shell Linux

Introduction

En scripting shell Linux, la terminaison appropriée des scripts est essentielle pour une gestion efficace des ressources système et un comportement fiable des applications. La commande exit est un outil fondamental qui permet aux programmeurs de terminer l'exécution d'un script à des points spécifiques et de communiquer le statut d'exécution du script au processus appelant.

Ce lab (atelier) vous présentera le concept de sortie de script shell, l'importance des codes de statut de sortie et comment les implémenter dans vos scripts. En maîtrisant la commande exit, vous écrirez des scripts shell plus robustes qui libèrent correctement les ressources système et communiquent leur statut d'exécution à d'autres programmes.

Comprendre les bases de la commande exit

La commande exit est utilisée pour terminer un script shell et restituer le contrôle au processus appelant. Lorsqu'un script atteint la commande exit, il arrête immédiatement d'exécuter toutes les lignes de code suivantes.

La syntaxe de base de la commande exit est la suivante :

exit [status]

Où [status] est une valeur numérique optionnelle comprise entre 0 et 255 qui indique le statut de sortie du script. Si aucun statut n'est fourni, le statut de sortie sera celui de la dernière commande exécutée.

Explorons la commande exit en exécutant quelques tests simples dans votre terminal. Tout d'abord, accédez à votre répertoire de projet :

cd ~/project

Maintenant, essayons une simple sortie de ligne de commande. Tapez ce qui suit dans votre terminal :

echo "This will print" && exit && echo "This will not print"

Vous remarquerez que le terminal affiche "This will print" mais pas "This will not print" car la commande exit a terminé la session shell immédiatement après son exécution.

Pour continuer avec le lab (atelier), vous devrez ouvrir un nouveau terminal ou démarrer une nouvelle session shell. Vous pouvez le faire en tapant :

bash

Cela démarrera une nouvelle session shell bash dans votre terminal actuel.

Création d'un script simple avec exit

Maintenant que vous comprenez le concept de base de la commande exit, créons un simple script shell qui l'utilise.

Tout d'abord, créez un nouveau fichier appelé simple_exit.sh dans votre répertoire de projet :

cd ~/project
touch simple_exit.sh

Ouvrez le fichier avec l'éditeur de texte nano :

nano simple_exit.sh

Ajoutez le contenu suivant au fichier :

#!/bin/bash
## Simple script demonstrating the exit command

echo "Script start"
echo "This line will be executed"

## Exit the script
exit

echo "This line will never be executed"
echo "Script end"

Enregistrez le fichier en appuyant sur Ctrl+O, puis sur Entrée, et quittez nano en appuyant sur Ctrl+X.

Maintenant, rendez le script exécutable :

chmod +x simple_exit.sh

Exécutez votre script :

./simple_exit.sh

Vous devriez voir la sortie suivante :

Script start
This line will be executed

Remarquez que les lignes après la commande exit ne sont jamais exécutées. Le script se termine immédiatement lorsqu'il atteint la commande exit.

La commande exit est particulièrement utile lorsque vous souhaitez arrêter l'exécution précocement en fonction de certaines conditions, comme vous le verrez dans les prochaines étapes.

Utilisation des codes de statut de sortie

Les codes de statut de sortie sont des valeurs numériques retournées par une commande ou un script pour indiquer si l'exécution s'est terminée avec succès. Dans les systèmes Linux et Unix-like :

• Un code de statut de sortie 0 indique un succès
• Un code de statut de sortie non nul (de 1 à 255) indique une erreur ou une autre condition exceptionnelle

Créons un script qui utilise différents codes de statut de sortie en fonction de certaines conditions.

Tout d'abord, créez un nouveau fichier de script :

cd ~/project
touch status_codes.sh

Ouvrez le fichier avec nano :

nano status_codes.sh

Ajoutez le contenu suivant :

#!/bin/bash
## Demonstrating exit status codes

## Check if a filename was provided as an argument
if [ $## -eq 0 ]; then
  echo "Error: No filename provided"
  echo "Usage: $0 <filename>"
  ## Exit with status 1 (general error)
  exit 1
fi

filename=$1

## Check if the file exists
if [ ! -f "$filename" ]; then
  echo "Error: File '$filename' not found"
  ## Exit with status 2 (file not found)
  exit 2
fi

## Check if the file is readable
if [ ! -r "$filename" ]; then
  echo "Error: File '$filename' is not readable"
  ## Exit with status 3 (permission denied)
  exit 3
fi

## If we get here, everything is fine
echo "File '$filename' exists and is readable"
## Exit with status 0 (success)
exit 0

Enregistrez le fichier (Ctrl+O, Entrée) et quittez nano (Ctrl+X).

Rendez le script exécutable :

chmod +x status_codes.sh

Maintenant, testons ce script dans différents scénarios.

Tout d'abord, exécutez le script sans aucun argument :

./status_codes.sh

Vous devriez voir :

Error: No filename provided
Usage: ./status_codes.sh <filename>

Le script s'est terminé avec le code de statut 1. Vous pouvez vérifier le code de statut de sortie de la dernière commande en utilisant la variable spéciale $? :

echo $?

Vous devriez voir :

1

Maintenant, créons un fichier de test et exécutons le script à nouveau :

echo "This is a test file" > testfile.txt
./status_codes.sh testfile.txt

Vous devriez voir :

File 'testfile.txt' exists and is readable

Vérifiez le code de statut de sortie :

echo $?

Vous devriez voir :

0

Cela indique que le script s'est terminé avec succès.

Enfin, essayons avec un fichier qui n'existe pas :

./status_codes.sh nonexistent_file.txt

Vous devriez voir :

Error: File 'nonexistent_file.txt' not found

Vérifiez le code de statut de sortie :

echo $?

Vous devriez voir :

2

Cela montre comment vous pouvez utiliser différents codes de statut de sortie pour indiquer différents types d'erreurs.

Utilisation du statut de sortie dans l'exécution conditionnelle

En script shell, les codes de statut de sortie sont souvent utilisés pour contrôler le flux d'exécution des commandes. Linux fournit deux opérateurs spéciaux à cet effet :

• && (opérateur ET) : La commande après && ne sera exécutée que si la commande précédente a réussi (statut de sortie 0)
• || (opérateur OU) : La commande après || ne sera exécutée que si la commande précédente a échoué (statut de sortie non nul)

Créons un script qui montre comment utiliser ces opérateurs avec les codes de statut de sortie.

Créez un nouveau fichier de script :

cd ~/project
touch conditional_exit.sh

Ouvrez le fichier avec nano :

nano conditional_exit.sh

Ajoutez le contenu suivant :

#!/bin/bash
## Demonstrating conditional execution using exit status

echo "Starting conditional execution test"

## Create a test directory
mkdir -p test_dir && echo "Directory created successfully" || echo "Failed to create directory"

## Try to create it again (this should "fail" since it already exists)
mkdir test_dir && echo "Directory created successfully" || echo "Failed to create directory"

## Check if a file exists and create it if it doesn't
[ -f test_file.txt ] && echo "File exists" || (echo "Creating file" && touch test_file.txt)

## Check again - now the file should exist
[ -f test_file.txt ] && echo "File exists" || echo "File doesn't exist"

## Example of using exit status with functions
check_number() {
  if [ $1 -gt 10 ]; then
    echo "Number is greater than 10"
    return 0 ## Success
  else
    echo "Number is less than or equal to 10"
    return 1 ## Failure
  fi
}

## Test the function with different values
check_number 5 && echo "Success case" || echo "Failure case"
check_number 15 && echo "Success case" || echo "Failure case"

echo "Test completed"

Enregistrez le fichier (Ctrl+O, Entrée) et quittez nano (Ctrl+X).

Rendez le script exécutable :

chmod +x conditional_exit.sh

Exécutez le script :

./conditional_exit.sh

Vous devriez voir une sortie similaire à celle-ci :

Starting conditional execution test
Directory created successfully
Failed to create directory
Creating file
File exists
Number is less than or equal to 10
Failure case
Number is greater than 10
Success case
Test completed

Examinons ce qui s'est passé :

1. La première commande mkdir -p test_dir a réussi, donc "Directory created successfully" a été affiché.
2. La deuxième commande mkdir test_dir a échoué (car le répertoire existe déjà), donc "Failed to create directory" a été affiché.
3. La vérification du fichier [ -f test_file.txt ] a initialement échoué, donc le fichier a été créé.
4. La deuxième vérification du fichier a réussi car le fichier existe maintenant.
5. La fonction check_number retourne un succès (0) pour les nombres > 10 et un échec (1) sinon.
   • Avec l'entrée 5, elle a retourné 1 (échec), donc "Failure case" a été affiché.
   • Avec l'entrée 15, elle a retourné 0 (succès), donc "Success case" a été affiché.

Cela montre comment les codes de statut de sortie peuvent être utilisés avec des opérateurs conditionnels pour créer des flux de contrôle plus sophistiqués dans vos scripts.

Résumé

Dans ce laboratoire, vous avez appris les concepts essentiels de la commande exit dans les scripts shell Linux :

1. La commande exit termine immédiatement l'exécution d'un script, empêchant tout code subséquent de s'exécuter.

2. Les codes de statut de sortie offrent un moyen standardisé pour que les scripts communiquent leur statut d'exécution :

   • Un code de statut de sortie 0 indique une exécution réussie
   • Des codes de statut de sortie non nuls (de 1 à 255) indiquent diverses conditions d'erreur

3. Vous pouvez vérifier le code de statut de sortie de la dernière commande en utilisant la variable spéciale $?.

4. Les codes de statut de sortie peuvent être utilisés avec des opérateurs conditionnels (&& et ||) pour contrôler le flux d'un script en fonction du succès ou de l'échec d'une commande.

Ces concepts sont fondamentaux pour créer des scripts shell robustes qui gèrent les erreurs de manière élégante et communiquent efficacement leur statut à d'autres programmes. En utilisant correctement les commandes exit et les codes de statut, vous assurez que vos scripts sont fiables, maintenables et fonctionnent bien avec les autres composants d'un système Linux.

Voici quelques bonnes pratiques à retenir :

• Fournissez toujours des codes de statut de sortie appropriés pour vos scripts
• Utilisez des messages d'erreur descriptifs accompagnés de codes de sortie spécifiques
• Documentez la signification des différents codes de sortie que votre script peut retourner
• Utilisez l'exécution conditionnelle (&& et ||) pour créer des scripts plus concis

Grâce à ces compétences, vous pouvez maintenant écrire des scripts shell plus professionnels et fiables pour une grande variété de tâches d'administration système et d'automatisation.