¶ III – Scripting avancé
¶ A – Documents intégrés
¶ 1 - Qu’est ce qu’un document intégré
Une « document intégré » est une solution simple et rapide permettant d’envoyer une suite de commandes à un programme interactif. C’est donc un bloc de code à usage spécial utilisant une forme de redirection d'entrée/sortie pour passer une liste de commandes à un programme ou à une commande interactifs, tel que par exemple « ftp », « cat » , « read, « wall », ou un éditeur de texte ex.
Cela permet donc la réalisation de scripts pour beaucoup de programmes dont certains non prévu à cet effet (du moment qu’ils prennent des entrées) mais également une meilleure lisibilité des entrées multilignes.
¶ 2 - Syntaxe
Un « document intégré » se compose de plusieurs parties :
- Le symbole « << »
- Un délimiteur
- Les entrées ou commandes
Le symbole spécial « << » précède le délimiteur et aura pour effet de rediriger la sortie d'un bloc de commandes vers le « stdin » (entrée) d'un programme ou d'une commande.
Le « délimiteur » encadre la liste de commande ou d’entrées et sert également à indiquer la fin de celles-ci.
Il peut être composé de n’importe quelle suite de caractères.
Attention : Choisissez une chaîne de caractères pour le délimiteur suffisamment inhabituelle pour qu'elle ne soit pas présente où que ce soit dans la liste de commandes afin qu'aucune confusion ne puisse survenir.
Toutefois, par convention on utilisera généralement « EOF » qui signifie « End Of Files ».
La syntaxe pour réaliser un « document intégré » est la suivante :
commande <<délimiteur
entrées..
entrées..
entrées..
délimiteur
L'option « - » marquant le délimiteur d'un document intégré, supprime les tabulations du début lors de la sortie. Attention cela supprime pas les espaces). Ceci est utile pour réaliser un script plus lisible.
¶ 3 – Quelques unes des possibilités d’un document intégré.
Voici une liste parmi tant d’autres de possibilités qu’offre un « document intégré » :
- Support de la substitution de variable.
- Support de la substitution de paramètres et de commandes.
Il est donc possible de passer différents paramètres dans le corps du « document intégré » en changeant la sortie de façon appropriée.
- Mettre entre guillemets ( ou échapper) le « délimiteur » au début du « document intégré » va désactiver la substitution de paramètres spéciaux en son corps Par exemple les caractères « $ », « ` » et « \ » seront alors interprétés littéralement.
Dans ce cas il sera écrit comme ceci : <<"délimiteur" ou <<’délimiteur’.
Désactiver la substitution de paramètres permet d'afficher le texte littéral. Générer des scripts, ou même du code, en est une des utilités principales.
- Initialiser une variable à partir de la sortie d'un document intégré.
- Permet de donner une entrée à une fonction du même script.
- Rediriger la sortie d’une commande appelée vers l’entrée d’un « document intégré ».
¶ 4 - Exemple : édition de texte
Comme nous l’avons indiqué, il est possible d’utiliser des documents intégrés afin de générer de manière scriptée des fichiers.
Nous allons créer un nouveau script appelé « docs_integres.sh » dans lequel nous choisirons ou non de faire appel à notre document intégré lors de l’exécution du script. Ce script comprendra également une suite permettant d’entrer un nombre puis de l’afficher.
Ici, nous avons donc le choix d’utiliser le « document intégré » ou non.
On lance le script et on choisit « OUI »
Le script se déroule correctement, le fichier est créé avec le contenu indiqué dans le « document intégré » puis ce contenu est affiché. Pour finir le script demande d’entrer un nombre et l’affiche.
On lance le script et on choisit « NON »
Dans ce cas, aucun fichier n’a été créé et seulement le nombre entré est affiché.
¶ 5 - Exemple : multilignes
Pour faire de l’affichage en multilignes nous avons plusieurs solutions.
Commençons par modifier le script « docs_integres.sh » :
Rappel : « \n » permet de signaler que la suite du texte sera à la ligne
si on lance le script on obtient ceci :
On peut constater que pour la première partie comme nous avons utilisé « \n » l’affichage est parfaitement lisible, ce qui n’est pas forcément le cas dans le corps du script.
Au contraire dans la deuxième partie, les tabulations ont été ajoutées conformément à la manière dont le corps du script a été écrit et ce n’est pas particulièrement « beau à lire » une fois le script lancé.
Dans ce cas, comment faire pour rendre à la fois le corps du script lisible mais également son résultat ?
Nous allons utiliser un « document intégré » ainsi que la commande « cat ».
reprenons notre script :
Ici le résultat sera bien lisible une fois le script lancé mais ne reste pas forcément clair dans le script lui-même (d’ordre général bien sûr, dans notre cas c’est lisible puisqu’il s’agit d’un exemple).
Toutefois lorsqu’on écrit un script on aime utiliser des tabulations pour rendre le contenu du script particulièrement facile à lire.
Dans ce cas pour pouvoir avec des tabulations dans le script mais également avoir un résultat sans tabulations une fois le script lancé, nous utiliserons une option des « documents intégrés » qui devra être positionnée sur le délimiteur.
L'option « - » marquant le délimiteur d'un « document intégré », supprime les tabulations du début lors de la sortie mais ne supprime pas les espaces. Ce qui est très utile pour réaliser un script plus lisible.
La syntaxe est la suivante :
commande <<-délimiteur
entrées..
entrées..
entrées..
délimiteur
Voici le résultat :
¶ 6 - Exemple : Substitution de variable
Nous l’avons dit, nous pouvons faire de la substitution de variable dans un « document intégré ».
On va donc remodifier un peu notre script « docs_integres.sh » pour en faire la démonstration.
Une fois le script lancé, la variable sera alors correctement substituée par sa valeur, ici mon prénom.
¶ 7 - Exemple : redirection de la sortie d’une commande appelée vers l’entrée d’un document intégré
Il est possible de rediriger la sortie d’une commande appelée vers l’entrée d’un « document intégré »
La syntaxe sera la suivante :
commande > fichier <<délimiteur
On lance le script
Plus rien n’apparait à l’écran à part la commande « read », c’est normal.
Ici la commande « cat » va rediriger sa sortie non pas vers le terminal mais un fichier appelé « cat.out ».
Ce fichier sera utilisé en entrée du « document intégré » lui permettant de rediriger lui aussi son résultat dans le fichier « cat.out » et non plus dans le terminal.
Si on regarde le contenu du fichier « cat.out » nous retrouvons effectivement le texte du « document intégré ».
¶ B – Les Chaînes intégrées
¶ 1 - Qu’est ce qu’une chaîne intégrée
Une « chaîne intégrée » ou « chaine en ligne » est une forme « minimale » de document intégré.
Elle va permettre de n’envoyer qu’une chaîne simple à une commande.
Autrement dit , le principe et les fonctionnalités sont les mêmes qu’avec un document intégré mais il n’y aura ici qu’une seule ligne et on n’utilisera pas de délimiteur.
Une chaîne intégrée peut être particulièrement pratique lorsqu’on veut tester un script notamment ceux qui nécessitent de nombreuses entrées utilisateur.
La syntaxe est la suivante :
commande <<<chaîne
La chaîne sera initialisée par l’entrée standard (« stdin ») de la commande.
¶ 2 - Exemple
Pour cet exemple, il ne sera pas utile de recréer un script complet.
Reprenons notre script « docs_integres.sh » pour le modifier.
Dans cet exemple, nous utilisons deux chaines intégrées.
La première va permettre de définir la variable « $prenom », qui est attendue par la commande « read », à l’aide de la chaine se trouvant derrière les symboles « <<< » puis d’afficher une phrase la contenant.
La deuxième va permettre de définir une variable « $nom », elle aussi attendue par la commande « read », à l’aide cette fois-ci de la variable se trouvant derrière les symboles « <<< » et qui aura été initialisée auparavant dans le script.
Pour finir puis echo affichera le résultat y compris le contenu de la variable « nom ».
Lançons le script maintenant pour voir le résultat :
¶ C – Sous-shells et shells restreints
¶ 1 – Sous-Shell
¶ 1.1 - Définition
Lorsqu’on exécute un script, il lance un nouveau processus appelé « un sous-shell ».
Un « sous-shell » est donc un processus fils lancé par un shell ou un script.
Il s’agit d’une instance séparée du gestionnaire de commande qui permettra d’exécuter son propre « flot » de commandes.
Chaque script en cours d'exécution est d’ailleurs un sous-processus ou processus enfant du shell parent.
Un script peut également lancer lui-même des « sous-shells » qui permettent au script de faire de l'exécution en parallèle et donc d'exécuter différentes tâches simultanément.
En général, une commande externe dans un script lance un sous-processus alors qu'une commande intégrée de Bash ne le fait pas.
Pour cette raison les commandes intégrées s'exécutent plus rapidement et utilisent moins de ressources que leurs commandes externes équivalentes.
¶ 1.2 – La syntaxe
Pour exécuter une liste de commande dans un « sous-shell », celles-ci devront être placées entre parenthèses :
(
commande1
commande2
commande3
)
Ou alors :
( commande1; commande2; commande3 )
Il est possible d’utiliser autant de commande que l’on veut.
Les variables utilisées dans un « sous shell » ne sont pas visibles en dehors du code même du sous-shell.
Elles ne seront donc pas utilisables par le processus parent (le shell qui a lancé le sous-shell).
En effet, ces variables sont des variables locales du processus enfant uniquement.
Chaque commande externe appelé dans un shell lance son propre processus mais ce n’est pas le cas des commandes interne.
Cela permet d’ailleurs de consommer moins de ressources.
Lorsqu’on fait du scripting, de nombreuses commandes peuvent être utilisées pour nous faciliter la tâches et permettre d’arriver à nos fins. Cependant avec les « sous-shells » il faut savoir que certaines d’entre elles auront un comportement bien particulier.
- La commande « exit » : Cette commande ne terme que le processus courant, si elle est utilisée dans un « sous-shell » alors elle ne mettra fin qu’à celui-ci et non au script lui-même.
- La commande « cd » : Si cette commande est effectuée au sein d’un « sous shell » alors elle n’aura d’impact que sur celui-ci.
Il est possible d’exécuter deux « sous-shells » en parallèle en les séparant par le symbole « & ». Dans ce cas il ne faut pas faire de retour à la ligne.
¶ 1.3 - exemple
On va faire un petit exemple de sous-shells en parallèle. Pour cela nous allons créer le script « sous-shell.sh » et le remplir comme ceci :
Ici le script va effectuer les actions suivantes :
- Lancer la commande « echo » pour affichera que le script commence
- Créer deux « sous-shells » en parallèle
- Le premier se déplacera dans « / » et y fera la commande « pwd » afin de vérifier que nous sommes bien à la racine et affichera « ceci est le sous-shell N°1 »
- Le deuxième se déplacera dans « /etc » pour y faire également un « pwd » et vérifier que nous sommes bien dans « /etc ». Il affichera également qu’il s’agit du « sous-shell » N°2.
- Pour finir le script lancera la commande « echo » qui affichera que le script est terminé
Attention : il n’y a pas forcément d’ordre d’exécution entre les deux « sous-shells ». Ils se font en parallèle. Il est possible que l’affichage lors de la sortie donne un résultat un peu étrange. Ce n’est pas grave le script s’est correctement déroulé dans son ensemble.
¶ 2 – Shell Restreint
¶ 2.1 - Définition
Lorsqu’on exécute un script ou une partie d’un script en mode « restreint », certaines commandes sont désactivées.
Sans le mode restreint, elles seraient tout à fait fonctionnelles.
Celle permet de limiter les droits de l'utilisateur du script et donc minimiser les risques liés à l'exécution du script.
Par exemple, les commandes et actions suivantes sont désactivées lors de l’utilisation du mode « restreint » :
- L'usage de cd pour changer de répertoire de travail.
- Le changement de valeur des variables d'environnement (« SHELL », « ENV »).
- La lecture ou le remplacement d'options d'environnement de shell (« $SHELLOPTS »).
- La redirection de sortie.
- L'appel à des commandes contenant un ou plusieurs « / ».
- L'appel à « exec » pour substituer un processus différent de celui du shell.
- Diverses autres commandes qui pourraient permettre de détourner le script de son objectif initial.
- La sortie du mode restreint à l'intérieur d'un script.
¶ 2.2 - La syntaxe
La syntaxe du mode restreint peut être représentée de de manières différentes :
set -r
ou
set –restricted
Attention : commencer le script avec « #!/bin/bash -r » lance le script entier en mode restreint
¶ 2.3 - Exemple
Nous allons créer un script appelé « restreint.sh ».
Dans ce script, nous allons commencer par une partie en « mode normal » puis finir en mode « restreint ».
Pour commencer dans la première partie de ce script nous allons changer de répertoire et afficher le répertoire dans lequel nous nous trouvons.
Ensuite nous retournons dans le répertoire de l’utilisateur courant et à nouveau nous affichons le répertoire dans lequel nous nous trouverons.
Dans la seconde partie du script, nous allons passer en mode restreint et tenter de changer de répertoire pour afficher le répertoire dans lequel nous serons puis de changer la variable d’environnement « $SHELL ».
Pour finir, toujours en mode restreint, nous tenterons de rediriger la sortie d’une commande et d’afficher le fichier que l’on a tenté de créer.
On lance le script :
La première partie du script s’est correctement déroulée puisque nous étions en mode normal cependant la seconde partie n’a pas fonctionnée correctement puis que dans le mode restreint certains commandes ne sont pas autorisées, tel que nous l’avons indiqué précédemment.
¶ D – Fonctions et alias
¶ 1 – Les Fonctions
¶ 1.1 - définition
Une « fonction » est un ensemble d’instructions permettant d'effectuer plusieurs tâches avec des paramètres d'entrée différents.
Il s’agit d’une sorte de « sous-routine » ou d’un « bloc de code » qui implémente un ensemble d'opérations pour réaliser une tâche spécifique.
Par exemple, lorsqu’il y a un code répétitif ou une tâche qui se répète avec quelques légères variations dans la procédure, alors il est conseillé d’utiliser une fonction ce qui permettra de rentre le script beaucoup plus lisible et structuré.
¶ 1.2 – Quelques points importants à savoir
Avant de rentrer un peu plus dans le détail voici quelques points à savoir :
- Il est possible d’appeler une « fonction » autant de fois que l’on veut dans un script.
- Il n’y a pas de limite dans le nombre de fonction mais elles ne doivent pas avoir le même nom.
- Il est possible de réutiliser les variables globales initialisées dans votre script à l'intérieur ou à l'extérieur de votre fonction.
- Il est possible de déclarer des variables locales dans une ou plusieurs fonctions.
- Une bonne fonction, c'est une fonction qui traite d'un élément spécifique et récurrent dans votre script.
- Une fonction doit rester le plus générique possible puisque son utilisation permettra de réutiliser un bloc d’instruction sans coder et faire des doublons
- Lors de l’appel d’une fonction, il est possible de lui passer des paramètres (ou arguments) comme on le ferai avec un script : $1 $2 $3, etc.
- Une fonction ne peut pas être vide.
- Une fonction renvoie également un code de sortie.
¶ 1.3 – La syntaxe et l’appel de la fonction
Il existe deux méthodes pour déclarer une fonction :
function Nom_de_la_fonction
{
bloc d’instructions
}
Ou alors
Nom_de_la_fonction()
{
bloc d’instructions
}
Attention : Cette manière de déclarer une fonction est la plus courante et la plus utilisée.
Pour déclarer une fonction, il suffira simplement d’écrire dans le script le nom de la fonction
Nom_de_la_fonction
Ou alors si on souhaite lui passer des arguments :
Nom_de_la_fonctionargument1 argument2 etc
¶ 1.4 – exemple
Pour commencer cet exemple nous allons créer un script appelé « fonctions.sh » et y définir une fonction vide
Puis on lance le script
Le script ne marche pas et c’est normal, une fonction ne peut pas être vide.
Modifions notre fonction pour qu’elle ne soit plus vide
Et lançons le script :
Le script marche, la fonction à bien été déclarée puis appelée.
Maintenant que l’on voit comment marche une fonction nous allons passer à un exemple avec passage d’arguments à la fonction.
Pour cela nous allons modifier notre script comme ceci :
On lance le script pour voir le résultat :
Evidemment, ici ce ne sont que des exemples très simples pour voir la syntaxe et le fonctionnement des fonctions.
Dans un « vrai » script on ne mettra pas ce type de fonction en place.
Autre exemple, nous l’avons dit une fonction renvoie également un code de sortie lors de son exécution.
Voyons ce que ça donne. Pour cela, nous allons commenter ou supprimer tout le contenu du script et y ajouter les lignes suivantes.
Attention : Ici pour sortir de la fonction nous utilisons « return ». En effet, si l’on utilise « exit » comme nous le faisons généralement, nous sortirions directement du script.
Dans ce script, notre fonction va tester la valeur de « $1 » pour vérifier si elle est différente de « test ». Si tel est le cas alors la valeur de la variable sera affichée. Cependant si la valeur est égale à « test » alors la fonction sera arrêtée et le code de sortie « 10 » sera affiché.
Encore un autre exemple dans lequel nous allons modifier les couleurs d’un texte. les codes couleurs à utiliser sont les suivants :
noir='\e[0;30m'
gris='\e[1;30m'
rougefonce='\e[0;31m'
rose='\e[1;31m'
vertfonce='\e[0;32m'
vertclair='\e[1;32m'
orange='\e[0;33m'
jaune='\e[1;33m'
bleufonce='\e[0;34m'
bleuclair='\e[1;34m'
violetfonce='\e[0;35m'
violetclair='\e[1;35m'
cyanfonce='\e[0;36m'
cyanclair='\e[1;36m'
grisclair='\e[0;37m'
blanc='\e[1;37m'
neutre='\e[0;m'
Attention : quand on utilise un code couleur, il faut toujours finir par un « neutre » sinon tout le bash sera modifié.
Une fois le script lancé nous aurons le résultat suivant :
¶ 2 – Les Alias
¶ 2.1 - définition
Un « alias » en Bash est une sorte de raccourci clavier, un moyen d'éviter de taper une longue séquence de commande.
Pour déclarer un alias il suffit d’utiliser la commande du même nom « alias »
alias nom_de_l’alias="commande"
Cette manière de faire permettra de créer des alias de manière temporaire.
Il est toutefois possible de rendre un alias permanant en éditant le fichier « ./bashrc »
Par exemple si nous incluons la ligne « alias la="ls -la" » dans le fichier « ~/.bashrc » alors chaque commande « la » saisie sur la ligne de commande sera automatiquement remplacé par un « ls -la ».
Créer des alias permet de gagner du temps lors de la saisie en ligne de commande mais évite également d’avoir à se rappeler certaines combinaisons de commande qui peuvent être complexe.
Pour supprimer un alias, il suffira d’utiliser la commande « unalias »
Cependant il faut savoir que l’utilisation d’alias dans un script reste peu utilisé car assez limité.
¶ 2.2 - exemple
Par exemple, j’ai personnellement modifié le fichier « ~/.bashrc » de la VM que j’utilise pour cette documentation pour créer l’alias suivant :
Plutôt que de taper la commande « ls -l » je n’ai qua taper « ll » pour avoir le même résultat.
Le fichier « ~/.bashrc » vous permettra d’y entrer de nombreux alias selon votre bon vouloir.
Il est possible de faire la même chose dans un script mais ce n’est pas forcément conseillé.
¶ E – Les librairies
¶ 1 - Définition
Une « librairie » ou « bibliothèque » est un sous-ensemble de fonctions et de programmes correctement validés et testés regroupés au sein d'une même archive.
Elles sont utilisées pour éviter décrire à nouveau des lignes de code dans un script mais également pour centraliser des informations qui pourraient être utilisées par différents script.
Pour créer une librairie ou une bibliothèque, il suffit de créer un fichier comme nous le ferions avec un script mais cette fois-ci nous n’y indiquerons pas de shebang sur la première ligne.
Par exemple si nous voulions utiliser une librairie permettant de gérer les codes couleur et une fonction permettant de les appeler, comme nous l’avons vu précédemment, nous allons créer un simple fichier dont le contenu sera le suivant :
L’idéal sera de donner un nom cohérent à la librairie pour savoir à quoi elle sert mais il faudra impérativement qu’elle se termine en « .sh » comme pour les script.
Personnellement pour faire la différence entre les scripts ou les librairie je conseille d’utiliser « .lib.sh ».
¶ 2 - Utilisation
À l'intérieur d'un script, un « source nom-fichier » charge le fichier « nom-fichier ».
Exécuter le « source » d'un fichier importe alors le code de ce fichier dans le script.
Le résultat est le même que si les lignes « sourcées » du code étaient présentes dans le corps du script.
Ceci est utile dans les situations où de multiples scripts utilisent un fichier de données communes ou une bibliothèque de fonctions
Pour utiliser une librairie dans un script, il faudra « l’importer » dans le corps du script.
Il existe deux manières de faire :
source «chemin_de_la_librairie»
ou alors
. «chemin_de_la_librairie»
Attention : Si le script se trouve dans le même répertoire que la librairie il sera possible de remplacer le chemin complet par le nom de la librairie.
Nous allons modifier notre script « fonctions.sh » pour y inclure l’import de la librairie précédemment créé ainsi que quelques appels de fonction permettant de vérifier si l’import a fonctionné.
Puis on lance le script pour voir le résultat
Attention : Bien que cela fonctionne en Bash, si l’utilisation de librairies est nécessaire il sera alors vivement conseillé d’utiliser un autre langage de programmation tel que python par exemple.
¶ F – Listes et tableaux
¶ 1 - Définition
Les versions récentes de Bash supportent les tableaux à une dimension.
Une liste ou un tableau sous bash correspond à une variable qui va contenir plusieurs éléments rangés de manière ordonnées.
Chaque élément de la liste ou du tableau sera référencé par un « indice ».
Sous bash, le premier élément sera référencé par un « 0 »
Par défaut dans les autres langages de programmation, un tableau possède une taille prédéfinie en fonction du nombre d’éléments qu’il contient. Une liste fonctionne de la même manière sauf qu’elle ne contient pas une taille prédéfinie en fonction d’un nombre d’éléments. C’est donc un tableau qui n’a pas de taille prédéfinie.
Dans les faits en bash quand on parle de tableau, on fait plutôt référence à des listes. En effet dans bash il n’y a pas de taille définie pour les tableaux. Il est possible de rajouter des éléments comme on veut.
¶ 2 – Affectation ou déclaration d’un tableau
Pour déclarer un tableau il existe de manières différentes.
- Déclaration de l’ensemble d’un tableau :
nom_du_tableau=(valeur1 valeur2 valeur3)
Cette méthode permet de déclarer en une seule fois tout le contenu du tableau.
Ici, la « valeur1 » correspondra à l’élément du tableau dont l’indice est de « 0 », « valeur2 » aura l’indice « 1 », etc.
Attention il n’y a pas de guillemets autour des valeurs, elles sont simplement séparée par des espaces.
- Déclaration d’un élément d’un tableau :
nom_du_tableau[indice]="valeur"
ici l’indice correspond au numéro de l’élément pour lequel on souhaite affecter une valeur.
Attention : Cette fois-ci, la valeur sera entre guillemets.
¶ 3 – Démonstration
Par convention, un tableau est généralement appelé « array ».
Pour accéder à un élément dans un tableau, il faudra utiliser la commande suivante :
echo ${nom_du_tableau[indice]}
Le résultat sera le suivant
Nous allons faire la même chose mais en modifiant au passage un des éléments du premier tableau
On relance le script
La première partie affiche les différents éléments qui ont été définis dans nos tableau et la deuxième partie affiche à présent l’élément qui a été modifié dans l’un des deux tableaux.
¶ 4 – Les variables dans les tableaux
Il faut savoir que toutes les opérations de chaine déjà connues sur les variables sont également réalisables lors de l’utilisation d’un tableau.
Par exemple, il sera possible de savoir le nombre d’éléments dans un tableau :
Ou encore d’afficher tous les éléments d’un tableau :
¶ 5 – points importants
- Le premier indice d’un tableau est toujours « 0 »
- ${tableau} fait référence au premier éléments d’un tableau et non pas au tableau en entier.
- Un tableau bash n’a pas de taille fixe, il s’apparente donc beaucoup plus à une liste
¶ G – Débogage
¶ 1 - Introduction
Bash ne contient pas de débogueur intégré mais seulement des commandes et des expressions.
Les erreurs de syntaxe et fautes de frappe génèrent généralement des messages d'erreur incompréhensibles qui n'apportent pas forcément une aide claire pour déboguer un script non fonctionnel.
De plus, le message d'erreur ne fait pas nécessairement référence à la ligne où se trouve l'erreur mais à la ligne où l'interpréteur Bash s'aperçoit de l'erreur.
Les messages d'erreur peuvent ne pas tenir compte des lignes de commentaires d'un script lors de l'affichage du numéro de ligne de l'instruction ayant provoqué une erreur de syntaxe.
Nous allons donc voir ici quelques astuces et outils pour déboguer un script.
¶ 2 – Faire attention et suivre l’exécution du script
Voici quelques recommandations pour suivre l’exécution d’un script :
- Utiliser la commande « echo » pour effectuer des affichages aux différents points clés. Comme il s’agit d’un élément qui est susceptible de revenir régulièrement dans le script, il est conseillé d’utiliser une fonction.
Ça tombe bien il existe justement une fonction qui a été créée dans ce but par « Stefano Falsetto »
### debecho (debug-echo) par Stefano Falsetto ###
### Affichera les paramètres seulement si DEBUG est configuré. ###
debecho () {
if [ ! -z "$DEBUG" ]; then
echo "$1" >&2
# ^^^ sortie vers stderr
fi
}
Cette fonction permet d’avoir des messages d’erreurs qui seront tous redirigé vers la sortie d’erreur standard et qui ne seront affichées que si l’on a activé le mode debug grâce à la variable d’environnement « $DEBUG ».
Il sera alors possible d’utiliser le script de manière normale ou alors de le tester en utilisant la variable d’environnement « $DEBUG » quand on aura besoin de débuguer le script.
Exemple :
DEBUG=on
Whatever=whatnot
debecho $Whatever # affichera whatnot
DEBUG=
Whatever=notwhat
debecho $Whatever # N'affichera rien
- Filtrer les sorties de commandes grâce à « tee »
« tee » est une commande « POSIX » qui permet de lire depuis l'entrée standard et écrire sur la sortie standard tout en écrivant en parallèle dans des fichiers. Elle est notamment utile dans des tubes (pipe) pour relayer la sortie à une nouvelle commande tout en la sauvegardant dans un fichier sans affecter le résultat.
On pourrait voir la manipulation comme ceci :
commande | commande |tee «nom_du_fichier» | commande>sortie du tube
Exemple :
cat listefichiers* | sort | tee fichier.verif | uniq > fichier.resultat
Dans cet exemple, le fichier « fichier.verif » contient les contenus concaténés puis triés des fichiers « listefichiers » avant que les doublons ne soient supprimés par « uniq ».
Ceci est utile pour envoyer le résultat du processus en cours vers un fichier ou un papier, par exemple pour des raisons de débogage.
- Utiliser la variable LINENO
Cette variable correspond au numéro de la ligne du script dans lequel elle apparait.
C’est-à-dire qu’elle prend automatiquement pour valeur le numéro de la ligne à laquelle elle est appelée dans un script.
Elle n'a de signification que dans le script où elle apparait et est surtout utilisée dans les phases de débogage.
Exemple :
Autre exemple :
¶ 3 – Quelques recommandations
- Tester chaque variables et conditions aux points critiques
Pour cela il sera possible de créer et d’utiliser une fonction « assert ».dont l’idée est empruntée du langage « C ».
Elle permettra de sortir du script avec un message d’erreur spécifique en cas de nom respect d’une condition donnée, tel que par exemple tester si une variable est un nombre.
Exemple de fonction :
#!/bin/bash
# assert.sh
assert () # Si la condition est fausse,
{ # on sort du script avec un message d'erreur.
E_PARAM_ERR=98
E_ASSERT_FAILED=99
if [ -z "$2" ] # Pas assez de paramètres passés
then # à la fonction assert().
return $E_PARAM_ERR # Pas de dommages.
fi
noligne=$2
if [ ! $1 ]
then
echo "Mauvaise assertion : \"$1\""
echo "Fichier \"$0\", ligne $noligne"
# Donne le nom du fichier et le numéro de ligne
exit $E_ASSERT_FAILED
# else (sinon)
# return (retour)
# et continue l'exécution du script.
fi
}
- La commande « trap » pour intercepter le signal « EXIT » et afficher un message personnalisé en cas d’arrêt du script
Cette commande spécifie une action à la réception d'un signal ce qui est également très utile pour le débogage.
Attention : Un signal est un simple message envoyé au processus, soit par le noyau soit par un autre processus lui disant de réaliser une action spécifiée (habituellement pour finir son exécution). Par exemple, appuyer sur Control-C envoie une interruption utilisateur, un signal INT, au programme en cours d'exécution.
Si l’on tape « trap '' 2 », alors on va ignorer l'interruption 2 (qui correspond au Control-C), sans aucune action définie.
Par contre si l’on tape « trap 'echo "Control-C désactivé."' 2 » alors on va afficher le message « Control-C désactivé » lorsque Control-C est utilisé.
Exemple :
Ici lors de la réception du signal « EXIT » qui correspond au signal généré lors de la sortie du script, la commande « trap » va s’effectuer et lancer la commande «echo qui affichera le message « liste de variables --- a = 39 b = 36 »
¶ H – Options de bash
Les options sont des paramétrages permettant de modifier le comportement du shell et/ou du script.
Il est possible de les activer soit
- Au lancement du script via l’interpréteur (c’est-à-dire le shebang ou en ligne de commande)
- En cours d’exécution via la commande « set »
Pour activer une option dans un script, il faudra utiliser « set -o nom » ou « set -abréviation ».
Pour désactiver une option dans un script, il faudra utiliser « set +o nom » ou « set +abréviation ».
Dans les deux cas, les deux formes sont équivalentes et auront les mêmes résultats.
Exemple pour activer une option :
set -o verbose
set -v
Exemple pour désactiver une option :
set +o verbose
set +v
Voici un tableau récapitulatif des différentes options :
| Abréviations | Noms | Descriptions |
| -C | noclobber | Empêche l'écrasement de fichiers par une redirection (peut être outrepassé par >|) |
| -D | (aucune) | Affiche les chaînes entre guillemets préfixées par un $ mais n'exécute pas les commandes du script. |
| -a | allexport | Exporte toutes les variables définies |
| -b | notify | Notifie lorsque un travail en tâche de fond se termine (n'est pas d'une grande utilité dans un script) |
| -c ... | (aucune) | Lit les commandes à partir de ... |
| -e | errexit | Annule un script à la première erreur lorsqu'une commande quitte avec un statut différent de zéro (sauf pour les boucles until ou while, les tests if et les constructions de listes) |
| -f | noglob | Expansion des noms de fichier désactivée |
| -i | interactive | Script lancé dans un mode interactif |
| -n | noexec | Lit les commandes du script, mais ne les exécute pas (vérification de syntaxe) |
| -o Nom-Option | (aucune) | Appelle l'option Nom-Option |
| -o posix | POSIX | Modifie le comportement de Bash, ou du script appelé, pour se conformer au standard POSIX. |
| -o pipefail | échec d'un pipe | Fait qu'un tube renvoie le code de sortie de la dernière commande dans le tube qui a renvoyé un code de sortie différent de zéro. |
| -p | privileged | Script lancé avec « suid » (attention !) |
| -r | restricted | Script lancé en mode restreint (voir le Chapitre 21, Shells restreints). |
| -s | stdin | Lit les commandes à partir de l'entrée standard (stdin) |
| -t | (aucune) | Sort après la première commande |
| -u | nounset | Essayer d'utiliser une variable non définie affiche un message d'erreur et force l'arrêt du script |
| -v | verbose | Affiche chaque commande sur stdout avant de les exécuter |
| -x | xtrace | Similaire à -v, mais étend les commandes |
| - | (aucune) | Fin des options. Tous les autres arguments sont des paramètres de position. |
| -- | (aucune) | Désinitialise les paramètres de position. Si des arguments sont donnés (-- arg1 arg2), les paramètres de position sont initialisés avec ces arguments. |