105.2 Leçon 1
Certification : |
LPIC-1 |
---|---|
Version : |
5.0 |
Thème : |
105 Shells et scripts shell |
Objectif : |
105.2 Personnaliser ou écrire des scripts simples |
Leçon : |
1 sur 2 |
Introduction
L’environnement shell de Linux permet d’utiliser des fichiers — appelés scripts — qui contiennent des commandes de n’importe quel programme disponible dans le système en combinaison avec les commandes intégrées au shell afin d’automatiser les tâches personnalisées de l’utilisateur et/ou du système. En effet, bon nombre des tâches de maintenance du système d’exploitation sont effectuées par des scripts constitués de séquences de commandes, de structures décisionnelles et de boucles conditionnelles. Bien que les scripts soient généralement destinés à des tâches liées au système d’exploitation lui-même, ils sont également utiles pour des tâches orientées utilisateur comme le renommage en masse de fichiers, la collecte et l’analyse de données ou toute autre activité répétitive en ligne de commande.
Les scripts ne sont rien d’autre que des fichiers texte qui se comportent comme des programmes. Un vrai programme — l’interpréteur — lit et exécute les instructions qui figurent dans le script. L’interpréteur peut également lancer une session interactive dans laquelle les commandes — y compris les scripts — sont lues et exécutées au fur et à mesure qu’elles sont saisies, comme c’est le cas dans les sessions du shell Linux. Les scripts permettent de regrouper ces instructions et ces commandes lorsqu’elles deviennent trop complexes pour être implémentées sous forme d’alias ou de fonctions shell personnalisées. En outre, les scripts peuvent être maintenus comme des programmes conventionnels et, dans la mesure où il ne s’agit que de simples fichiers texte, ils peuvent être créés et modifiés à l’aide de n’importe quel éditeur de texte courant.
Structure et exécution d’un script
En principe, un script est une séquence ordonnée de commandes qui doivent être exécutées par l’interpréteur de commandes correspondant. La façon dont un interpréteur lit un script peut varier et il y a plusieurs façons de le faire dans une session du shell Bash, mais l’interpréteur par défaut pour un script sera celui indiqué dans la première ligne du script, juste après les caractères #!
(connus sous le nom de shebang). Dans un script qui contient des instructions pour l’interpréteur de commandes Bash, la première ligne doit être #!/bin/bash
. En indiquant cette ligne, l’interpréteur pour toutes les instructions du fichier sera /bin/bash
. À l’exception de la première ligne, toutes les autres lignes qui commencent par le caractère dièse #
seront ignorées, de sorte qu’elles peuvent être utilisées pour insérer des remarques et des commentaires. Les lignes vides sont également ignorées. Un script shell très basique peut donc s’écrire comme ceci :
#!/bin/bash # A very simple script echo "Cheers from the script file! Current time is: " date +%H:%M
Ce script n’a que deux instructions pour l’interpréteur /bin/bash
: la primitive du shell echo
et la commande date
. La façon la plus simple d’exécuter un script consiste à exécuter l’interpréteur avec le chemin du script en argument. Ainsi, en supposant que l’exemple précédent ait été sauvegardé dans un fichier script nommé script.sh
dans le répertoire courant, il sera lu et interprété par Bash avec la commande suivante :
$ bash script.sh Cheers from the script file! Current time is: 10:57
La commande echo
ajoutera automatiquement un retour à la ligne après avoir affiché le contenu, mais l’option -n
supprimera ce comportement. Ainsi, l’utilisation de echo -n
dans le script fera apparaître le résultat des deux commandes sur la même ligne :
$ bash script.sh Cheers from the script file! Current time is: 10:57
Bien que ce ne soit pas obligatoire, le suffixe .sh
permet d’identifier les scripts shell lors de l’affichage et de la recherche de fichiers.
Tip
|
Bash appellera la commande indiquée après le |
Si le script est censé être exécuté par d’autres utilisateurs du système, il est important de vérifier que les permissions en lecture sont correctes. La commande chmod o+r script.sh
accordera la permission en lecture à tous les utilisateurs du système, ce qui leur permettra d’exécuter script.sh
en indiquant le chemin vers le script comme argument de la commande bash
. Alternativement, le script peut avoir les permissions d’exécution définies de façon à ce que le fichier puisse être exécuté comme une commande conventionnelle. Les droits d’exécution sur le script sont activés avec la commande chmod +x
:
$ chmod +x script.sh
Si les droits en exécution sont définis, le script nommé script.sh
dans le répertoire courant peut être exécuté directement avec la commande ./script.sh
. Par ailleurs, les scripts rangés dans un des répertoires figurant dans la variable d’environnement PATH
seront accessibles sans leur chemin d’accès complet.
Warning
|
Un script qui exécute des actions restreintes peut avoir son autorisation SUID activée, de sorte que les utilisateurs ordinaires peuvent également exécuter le script avec les privilèges de l’administrateur. Dans ce cas, il est très important de s’assurer qu’aucun utilisateur autre que root n’a le droit d’écrire dans le fichier. Autrement, un utilisateur ordinaire pourrait modifier le fichier pour effectuer des opérations arbitraires et potentiellement dangereuses. |
L’emplacement et l’indentation des commandes dans les scripts ne sont pas trop rigides. Chaque ligne d’un script shell sera exécutée comme une commande shell classique, dans l’ordre dans lequel la ligne apparaît dans le script, et les règles qui valent pour l’invite shell s’appliquent également à chaque ligne individuelle du script. On peut écrire plusieurs commandes sur la même ligne, séparées par des points-virgules :
echo "Cheers from the script file! Current time is:" ; date +%H:%M
Même si ce format peut s’avérer pratique dans certains cas, son utilisation est facultative, étant donné que les commandes séquentielles peuvent être écrites à raison d’une commande par ligne et qu’elles seront exécutées comme si elles avaient été séparées par des points-virgules. En d’autres termes, le point-virgule peut être remplacé par un retour à la ligne dans les scripts Bash.
Lorsqu’un script est exécuté, les commandes qu’il contient ne sont pas exécutées directement dans la session en cours, mais par un nouveau processus Bash, appelé sous-shell (sub-shell). Cette technique permet d’éviter que le script n’écrase les variables d’environnement de la session en cours et qu’il ne laisse des modifications en suspens dans cette session. Si le but consiste à exécuter le script dans la session en cours, il doit être exécuté avec source script.sh
ou . script.sh
(notez qu’il y a un espace entre le point et le nom du script).
Comme pour l’exécution de n’importe quelle autre commande, l’invite du shell ne réapparaîtra qu’à la fin de l’exécution du script et son code d’état de sortie sera disponible dans la variable $?
. Pour changer ce comportement de manière à ce que le shell actuel se termine également avec le script, ce dernier — ou toute autre commande — peut être précédé de la commande exec
. Cette commande remplacera également le code d’état de sortie de la session en cours du shell par le sien.
Les variables
Les variables dans les scripts shell se comportent de la même manière que dans les sessions interactives, étant donné que l’interpréteur est le même. Par exemple, la syntaxe SOLUTION=42
(sans espace autour du signe égal) affectera la valeur 42
à la variable nommée SOLUTION
. Par convention, les noms de variables sont en majuscules, mais ce n’est pas obligatoire. En revanche, les noms de variables ne peuvent pas commencer par des caractères autres que ceux de l’alphabet.
En dehors des variables classiques créées par l’utilisateur, les scripts Bash disposent également d’un ensemble de variables spéciales appelées paramètres. Contrairement aux variables habituelles, les noms des paramètres commencent par un caractère non alphabétique qui désigne leur fonction. Les arguments passés à un script et d’autres informations utiles sont stockés dans des paramètres comme $0
, $*
, $?
, etc. où le caractère qui suit le signe du dollar indique l’information à récupérer :
$*
-
Tous les arguments passés au script.
$@
-
Tous les arguments passés au script. Avec des guillemets doubles comme dans
"$@"
, chaque argument sera entouré de guillemets doubles. $#
-
Le nombre d’arguments.
$0
-
Le nom du script.
$!
-
Le PID du dernier programme exécuté.
$$
-
Le PID du shell en cours.
$?
-
Code numérique de l’état de sortie de la dernière commande terminée. Pour les processus POSIX standard, une valeur numérique de
0
signifie que la dernière commande a été exécutée avec succès, ce qui s’applique également aux scripts shell.
Un paramètre positionnel est un paramètre désigné par un ou plusieurs chiffres, autres que le chiffre unique 0
. Par exemple, la variable $1
correspond au premier argument transmis au script (paramètre positionnel 1), $2
correspond au second argument, et ainsi de suite. Si la position d’un paramètre est supérieure à neuf, il doit être référencé avec des accolades, comme dans ${10}
, ${11}
, etc.
Les variables ordinaires, en revanche, sont destinées à stocker des valeurs insérées manuellement ou les résultats générés par d’autres commandes. La commande read
, par exemple, peut être utilisée par le script pour demander à l’utilisateur de saisir des données pendant l’exécution du script :
echo "Do you want to continue (y/n)?" read ANSWER
La valeur retournée sera stockée dans la variable ANSWER
. Si le nom de la variable n’est pas fourni, la variable REPLY
sera utilisée par défaut. Il est également possible d’utiliser la commande read
pour lire plusieurs variables en même temps :
echo "Type your first name and last name:" read NAME SURNAME
Dans ce cas, chaque terme séparé par un espace sera assigné respectivement aux variables NAME
et SURNAME
. Si le nombre de termes fournis est supérieur au nombre de variables, les termes en excès seront stockés dans la dernière variable. read
lui-même peut afficher le message à l’utilisateur avec l’option -p
, ce qui rend la commande echo
redondante dans ce cas :
read -p "Type your first name and last name:" NAME SURNAME
Les scripts qui exécutent des tâches système ont souvent besoin d’informations fournies par d’autres programmes. La notation avec guillemet inverse (backtick notation) peut être utilisée pour stocker la sortie d’une commande dans une variable :
$ OS=`uname -o`
Dans l’exemple, le résultat de la commande uname -o
sera stocké dans la variable OS
. On obtiendra le même résultat avec $()
:
$ OS=$(uname -o)
La longueur d’une variable, c’est-à-dire la quantité de caractères qu’elle contient, est retournée en faisant précéder le nom de la variable d’un dièse #
. Cette fonctionnalité nécessite toutefois l’utilisation de la syntaxe entre accolades pour indiquer la variable :
$ OS=$(uname -o) $ echo $OS GNU/Linux $ echo ${#OS} 9
Bash utilise également des variables de type tableau unidimensionnel, de sorte qu’un ensemble d’éléments apparentés peut être stocké dans une seule variable. Chaque élément d’un tableau possède un index numérique, qui doit être utilisé pour écrire et lire les valeurs de l’élément correspondant. Contrairement aux variables classiques, les tableaux doivent être déclarés à l’aide de la commande Bash declare
. Par exemple, pour déclarer une variable nommée SIZES
comme un tableau :
$ declare -a SIZES
Les tableaux peuvent également être déclarés implicitement lorsqu’ils sont constitués à partir d’une liste prédéfinie d’éléments, en utilisant la notation entre parenthèses :
$ SIZES=( 1048576 1073741824 )
Dans l’exemple, les deux entiers de taille importante ont été stockés dans le tableau SIZES
. Les éléments d’un tableau doivent être référencés à l’aide d’accolades et de crochets, faute de quoi Bash ne pourra pas modifier ou afficher l’élément correctement. Étant donné que les index des tableaux commencent à 0, le contenu du premier élément est dans ${SIZES[0]}
, le deuxième élément est dans ${SIZES[1]}
et ainsi de suite :
$ echo ${SIZES[0]} 1048576 $ echo ${SIZES[1]} 1073741824
Contrairement à la lecture, la modification du contenu de l’élément d’un tableau s’effectue sans les accolades (par exemple, SIZES[0]=1048576
). Comme pour les variables classiques, la longueur d’un élément d’un tableau est retournée avec le caractère dièse (par exemple, ${#SIZES[0]}
pour la longueur du premier élément du tableau SIZES
). Le nombre total d’éléments d’un tableau est retourné si @
ou *
sont utilisés comme index :
$ echo ${#SIZES[@]} 2 $ echo ${#SIZES[*]} 2
Les tableaux peuvent également être déclarés en utilisant le résultat d’une commande comme les éléments initiaux par le biais de la substitution de commande. L’exemple suivant montre comment créer un tableau Bash composé des systèmes de fichiers pris en charge par le système actuel :
$ FS=( $(cut -f 2 < /proc/filesystems) )
La commande cut -f 2 < /proc/filesystems
affiche tous les systèmes de fichiers actuellement pris en charge par le noyau en cours d’exécution (tels qu’ils sont listés dans la deuxième colonne du fichier /proc/filesystems
), de sorte que le tableau FS
contient maintenant un élément pour chaque système de fichiers pris en charge. Tout contenu texte peut être utilisé pour initialiser un tableau étant donné que, par défaut, n’importe quel terme délimité par des caractères espace, tabulation ou retour à la ligne constituera un élément du tableau.
Tip
|
Bash traite chaque caractère de la variable d’environnement |
Les expressions arithmétiques
Bash fournit une méthode pratique pour effectuer des opérations arithmétiques sur les nombres entiers avec la commande interne expr
. Deux variables numériques, $VAL1
et $VAL2
par exemple, peuvent être additionnées avec la commande suivante :
$ SUM=`expr $VAL1 + $VAL2`
La valeur résultante de l’exemple sera disponible dans la variable $SUM
. La commande expr
peut être remplacée par $(())
, de sorte que l’exemple précédent peut être réécrit comme SUM=$(( $VAL1 + $VAL2 ))
. Les puissances sont également autorisées avec l’opérateur double astérisque, de sorte que la déclaration de tableau précédente SIZES=( 1048576 1073741824)
peut être réécrite comme SIZES=( $((1024**2)) $((1024**3)) )
.
La substitution de commande peut également être utilisée dans les expressions arithmétiques. Par exemple, le fichier /proc/meminfo
contient des informations détaillées sur la mémoire du système, y compris le nombre d’octets libres dans la RAM :
$ FREE=$(( 1000 * `sed -nre '2s/[^[:digit:]]//gp' < /proc/meminfo` ))
L’exemple montre comment la commande sed
peut être utilisée pour analyser le contenu de /proc/meminfo
à l’intérieur de l’expression arithmétique. La deuxième ligne du fichier /proc/meminfo
indique la quantité de mémoire libre en milliers d’octets, l’expression arithmétique la multiplie donc par 1000 pour obtenir le nombre d’octets libres dans la RAM.
L’exécution conditionnelle
Certains scripts ne sont généralement pas destinés à exécuter la totalité des commandes du script, mais uniquement celles qui répondent à des critères prédéfinis. Par exemple, un script de maintenance peut envoyer un message d’avertissement à l’adresse e-mail de l’administrateur seulement si l’exécution d’une commande échoue. Bash fournit des méthodes spécifiques pour évaluer le succès de l’exécution d’une commande et des structures conditionnelles générales, semblables à celles que l’on peut trouver dans les langages de programmation classiques.
Lorsqu’on sépare les commandes par &&
, la commande de droite ne sera exécutée que si la commande de gauche n’a pas rencontré d’erreur, c’est-à-dire si son état de sortie était égal à 0
:
COMMAND A && COMMAND B && COMMAND C
Le comportement inverse se produit si les commandes sont séparées par ||
. Dans ce cas, la commande suivante ne sera exécutée que si la commande précédente a rencontré une erreur, c’est-à-dire si son code d’état de retour est différent de 0.
La possibilité d’exécuter des commandes en fonction de conditions préalablement définies constitue l’une des principales fonctionnalités de tous les langages de programmation. La manière la plus simple d’exécuter des commandes de manière conditionnelle consiste à utiliser la commande interne if
de Bash, qui exécute une ou plusieurs commandes uniquement si la commande fournie en argument renvoie un 0 (succès). Une autre commande, test
, peut être utilisée pour évaluer toute une série de critères spéciaux, elle est donc souvent utilisée de pair avec if
. Dans l’exemple suivant, le message Confirmed: /bin/bash is executable.
sera affiché si le fichier /bin/bash
existe et s’il est exécutable :
if test -x /bin/bash ; then echo "Confirmed: /bin/bash is executable." fi
L’option -x
fait en sorte que la commande test
retourne un code d’état 0 seulement si le chemin spécifié est un fichier exécutable. L’exemple suivant montre une autre façon d’obtenir exactement le même résultat, puisque les crochets peuvent remplacer test
:
if [ -x /bin/bash ] ; then echo "Confirmed: /bin/bash is executable." fi
L’instruction else
est une option de la structure if
et peut, si elle est utilisée, définir une commande ou une séquence de commandes à exécuter si l’expression conditionnelle n’est pas vérifiée :
if [ -x /bin/bash ] ; then echo "Confirmed: /bin/bash is executable." else echo "No, /bin/bash is not executable." fi
Une structure if
doit toujours se terminer par fi
, de sorte que l’interpréteur Bash sache où se trouve la fin d’une commande conditionnelle.
Afficher les résultats d’un script
Même si le but d’un script ne concerne que des opérations sur des fichiers, il est important d’afficher les messages relatifs à la progression dans la sortie standard, de manière à ce que l’utilisateur soit au courant des éventuels problèmes et qu’il puisse éventuellement utiliser ces messages pour générer des rapports d’opération.
La commande interne echo
de Bash est normalement utilisée pour afficher de simples chaînes de texte, mais elle offre également des fonctionnalités étendues. Avec l’option -e
, la commande echo
est capable d’afficher des caractères spéciaux en utilisant des séquences échappées (une séquence d’antislash désignant un caractère spécial). Par exemple :
#!/bin/bash # Get the operating system's generic name OS=$(uname -o) # Get the amount of free memory in bytes FREE=$(( 1000 * `sed -nre '2s/[^[:digit:]]//gp' < /proc/meminfo` )) echo -e "Operating system:\t$OS" echo -e "Unallocated RAM:\t$(( $FREE / 1024**2 )) MB"
L’utilisation des guillemets est facultative lorsqu’on utilise echo
sans option, mais elle devient nécessaire avec l’option -e
, autrement les caractères spéciaux risquent de ne pas s’afficher correctement. Dans le script ci-dessus, les deux commandes echo
utilisent le caractère de tabulation \t
pour aligner le texte, ce qui donne le résultat suivant :
Operating system: GNU/Linux Unallocated RAM: 1491 MB
Le caractère de retour à la ligne \n
peut être utilisé pour séparer les lignes du résultat, et l’on obtient la même chose en combinant les deux commandes echo
en une seule :
echo -e "Operating system:\t$OS\nUnallocated RAM:\t$(( $FREE / 1024**2 )) MB"
Même si elle permet d’afficher la plupart des messages texte, la commande echo
n’est pas forcément adaptée à l’affichage de motifs de texte plus complexes. La commande printf
intégrée à Bash offre plus de choix sur la façon d’afficher les variables. La commande printf
utilise le premier argument comme format de sortie, et les caractères de remplissage seront remplacés par les arguments successifs dans l’ordre où ils apparaissent dans la ligne de commande. Par exemple, le message de l’exemple précédent pourrait être généré avec la commande printf
suivante :
printf "Operating system:\t%s\nUnallocated RAM:\t%d MB\n" $OS $(( $FREE / 1024**2 ))
Le marqueur %s
est destiné au contenu textuel (il sera remplacé par la variable $OS
) et le marqueur %d
est destiné aux nombres entiers (il sera remplacé par le nombre de mégaoctets libres dans la RAM). printf
n’ajoute pas de caractère de retour à la ligne à la fin du texte, le caractère correspondant \n
doit donc être placé à la fin du motif si nécessaire. Le motif entier sera interprété comme un seul argument et doit donc être placé entre guillemets.
Tip
|
Le format de substitution des espaces réservés effectué par |
Avec printf
, les variables sont placées à l’extérieur du motif de texte, ce qui permet de stocker le motif dans une variable séparée :
MSG='Operating system:\t%s\nUnallocated RAM:\t%d MB\n' printf "$MSG" $OS $(( $FREE / 1024**2 ))
Cette méthode est particulièrement utile pour afficher des formats de sortie distincts, en fonction des besoins de l’utilisateur. Elle facilite, par exemple, l’écriture d’un script qui utilise un modèle de texte distinct si l’utilisateur souhaite une liste CSV (Comma Separated Values) plutôt qu’un message de sortie par défaut.
Exercices guidés
-
L’option
-s
de la commanderead
est utile pour saisir les mots de passe, étant donné qu’elle n’affiche pas le contenu tapé à l’écran. Comment pourrait-on utiliser la commanderead
pour stocker la saisie de l’utilisateur dans la variablePASSWORD
tout en masquant le contenu de la frappe ? -
Le seul rôle de la commande
whoami
consiste à afficher l’identifiant de l’utilisateur qui l’a appelée. C’est pourquoi elle est principalement utilisée dans les scripts pour identifier l’utilisateur qui l’exécute. Dans un script Bash, comment pourrait-on stocker le résultat de la commandewhoami
dans une variable nomméeWHO
? -
Quel opérateur Bash doit se trouver entre les commandes
apt-get dist-upgrade
etsystemctl reboot
si l’utilisateur root veut exécutersystemctl reboot
seulement siapt-get dist-upgrade
s’est terminé avec succès ?
Exercices d’approfondissement
-
Un utilisateur essaie d’exécuter un script Bash nouvellement créé, mais il est confronté au message d’erreur suivant :
bash: ./script.sh: Permission denied
Sachant que le fichier
./script.sh
a été créé par le même utilisateur, quelle pourrait être la cause probable de cette erreur ? -
Admettons qu’un fichier script nommé
do.sh
soit exécutable et que le lien symbolique nomméundo.sh
pointe vers lui. Depuis le script, comment pourriez-vous déterminer si le fichier qui l’appelle estdo.sh
ouundo.sh
? -
Dans un système avec un service de messagerie correctement configuré, la commande
mail -s "Maintenance Error" root <<<"Scheduled task error"
envoie un message de notification à l’utilisateur root. Une telle commande pourrait être utilisée dans des tâches automatiques comme les cronjobs pour informer l’administrateur du système d’un problème inattendu. Écrivez une fonction if qui exécutera la commandemail
mentionnée ci-dessus si le statut de sortie de la commande précédente — quelle qu’elle soit — est un échec.
Résumé
Cette leçon aborde les concepts de base qui permettent de comprendre et d’écrire des scripts shell Bash. Les scripts shell sont un élément essentiel de toute distribution Linux, étant donné qu’ils offrent un moyen très souple d’automatiser les tâches de l’utilisateur et du système effectuées dans l’environnement shell. La leçon passe par les étapes suivantes :
-
Structure des scripts shell et permissions correctes pour les fichiers de scripts
-
Paramètres des scripts
-
Utiliser des variables pour lire les informations saisies par l’utilisateur et pour stocker les résultats des commandes
-
Les tableaux unidimensionnels de Bash
-
Tests simples et exécution conditionnelle
-
Mise en forme de l’affichage des résultats
Voici les commandes et les procédures abordées :
-
Notation intégrée à Bash pour la substitution de commandes, l’expansion de tableaux et les expressions arithmétiques
-
Exécution conditionnelle des commandes avec les opérateurs
||
et&&
-
echo
-
chmod
-
exec
-
read
-
declare
-
test
-
if
-
printf
Réponses aux exercices guidés
-
L’option
-s
de la commanderead
est utile pour saisir les mots de passe, étant donné qu’elle n’affiche pas le contenu tapé à l’écran. Comment pourrait-on utiliser la commanderead
pour stocker la saisie de l’utilisateur dans la variablePASSWORD
tout en masquant le contenu de la frappe ?read -s PASSWORD
-
Le seul rôle de la commande
whoami
consiste à afficher l’identifiant de l’utilisateur qui l’a appelée. C’est pourquoi elle est principalement utilisée dans les scripts pour identifier l’utilisateur qui l’exécute. Dans un script Bash, comment pourrait-on stocker le résultat de la commandewhoami
dans une variable nomméeWHO
?WHO=`whoami`
ouWHO=$(whoami)
-
Quel opérateur Bash doit se trouver entre les commandes
apt-get dist-upgrade
etsystemctl reboot
si l’utilisateur root veut exécutersystemctl reboot
seulement siapt-get dist-upgrade
s’est terminé avec succès ?L’opérateur
&&
, comme dansapt-get dist-upgrade && systemctl reboot
.
Réponses aux exercices d’approfondissement
-
Un utilisateur essaie d’exécuter un script Bash nouvellement créé, mais il est confronté au message d’erreur suivant :
bash: ./script.sh: Permission denied
Sachant que le fichier
./script.sh
a été créé par le même utilisateur, quelle pourrait être la cause probable de cette erreur ?Le script
./script.sh
ne possède pas les droits d’exécution. -
Admettons qu’un fichier script nommé
do.sh
soit exécutable et que le lien symbolique nomméundo.sh
pointe vers lui. Depuis le script, comment pourriez-vous déterminer si le fichier qui l’appelle estdo.sh
ouundo.sh
?La variable spéciale
$0
contient le nom de fichier utilisé pour appeler le script. -
Dans un système avec un service de messagerie correctement configuré, la commande
mail -s "Maintenance Error" root <<<"Scheduled task error"
envoie un message de notification à l’utilisateur root. Une telle commande pourrait être utilisée dans des tâches automatiques comme les cronjobs pour informer l’administrateur du système d’un problème inattendu. Écrivez une fonction if qui exécutera la commandemail
mentionnée ci-dessus si le statut de sortie de la commande précédente — quelle qu’elle soit — est un échec.if [ "$?" -ne 0 ]; then mail -s "Maintenance Error" root <<<"Scheduled task error"; fi