La programmation Système avec Shell : Introduction
Les shells
Sous Unix, on appelle shell l’interpréteur de commandes qui fait office d'interface entre l'utilisateur et le système d’exploitation. Les shells sont des interpréteurs : cela signifie que chaque commande saisie par l’utilisateur (ou lue à partir d’un fichier) est syntaxiquement vérifiée puis exécutée.
Il existe de nombreux shells qui se classent en deux grandes familles :
- la famille C shell (ex : csh, tcsh)
- la famille Bourne shell (ex : sh, bash, ksh).
zsh est un shell qui contient les caractéristiques des deux familles précédentes. Néanmoins, le choix d’utiliser un shell plutôt qu’un autre est essentiellement une affaire de préférence personnelle ou de circonstance. En connaître un, permet d’accéder aisément aux autres. Lorsque l’on utilise le système GNU/Linux (un des nombreux systèmes de la galaxie Unix), le shell par défaut est bash (Bourne Again SHell). Ce dernier a été conçu en 1988 par Brian Fox dans le cadre du projet GNU. Aujourd’hui, les développements de bash sont menés par Chet Ramey.
Un shell possède un double aspect :
- un aspect environnement de travail
- un aspect langage de programmation.
-
Un environnement de travail
En premier lieu, un shell doit fournir un environnement de travail agréable et puissant. Par exemple, bash permet (entre autres) :
- le rappel des commandes précédentes (gestion de l’historique) ; cela évite de taper plusieurs fois la même commande
- la modification en ligne du texte de la commande courante (ajout, retrait, remplacement de caractères) en utilisant les commandes d’édition de l’éditeur de texte vi ou emacs
- la gestion des travaux lancés en arrière-plan (appelés jobs) ; ceux-ci peuvent être démarrés, stoppés ou repris suivant les besoins
- l’initialisation adéquate de variables de configuration (chaîne d’appel de l’interpréteur, chemins de recherche par défaut) ou la création de raccourcis de commandes (commande alias).
Illustrons cet ajustement de configuration par un exemple. Le shell permet d’exécuter une commande en mode interactif ou bien par l'intermédiaire de fichiers de commandes (scripts). En mode interactif, bash affiche à l’écran une chaîne d’appel (appelée également prompt ou invite), qui se termine par défaut par le caractère # suivi d’un caractère espace pour l’administrateur système (utilisateur root) et par le caractère $ suivi d’un caractère espace pour les autres utilisateurs. Cette chaîne d’appel peut être relativement longue.
Exemple : root@ubuntu-laptop:/home#
Celle-ci est constituée du nom de connexion de l’utilisateur (ici root), du nom de la machine sur laquelle l’utilisateur travaille (ici ubuntu-laptop) et du chemin absolu du répertoire courant de l’utilisateur (/home). Elle indique que le shell attend que l’utilisateur saisisse une commande et la valide en
appuyant sur la touche entrée. Bash exécute alors la commande puis réaffiche la chaîne d’appel. Si l’on souhaite raccourcir cette chaîne d’appel, il suffit de modifier la valeur de la variable prédéfinie du shell PS1 (Prompt Shell 1).
Exemple :
root@ubuntu-laptop:/home# PS1='$ '
# pwd
/home/ => pwd affiche le chemin absolu du repertoire courant
#
La nouvelle chaîne d’appel est constituée par le caractère $ suivi d’un caractère espace.
-
Un langage de programmation
Les shells ne sont pas seulement des interpréteurs de commandes mais également de véritables langages de programmation. Un shell comme bash intègre :
- les notions de variable, d’opérateur arithmétique, de structure de contrôle, de fonction, présentes dans tout langage de programmation classique, mais aussi
- des opérateurs spécifiques (ex : |, ;)
Exemple :
$ a=5 => affectation de la valeur 5 à la variable a
$
$ echo $((a +3 )) => affiche la valeur de a+3
8
$
L’opérateur |, appelé tube, est un opérateur caractéristique des shells et connecte la sortie d’une commande à l’entrée de la commande suivante.
Exemple :
$ ruptime
iutbis up 56+22:50, 0 users, load 0.47, 0.48, 0.34
jade up 39+16:17, 2 users, load 0.00, 0.00, 0.00
mobile1 up 3+02:19, 0 users, load 0.00, 0.00, 0.00
mobile2 up 2+18:43, 0 users, load 0.00, 0.00, 0.00
quartz up 40+15:35, 2 users, load 0.00, 0.00, 0.00
sigma up 56+23:46, 1 user, load 0.00, 0.00, 0.00
$
$ ruptime | wc -l
6
$
La commande unix ruptime affiche les noms et autres informations relatives aux machines visibles sur le réseau. La commande unix wc munie de l’option -l affiche le nombre de lignes qu’elle a été en mesure de lire. En connectant avec un tube la sortie de ruptime à l’entrée de la commande wc –l, on obtient le nombre de machines visibles du réseau.
Même si au fil du temps de nouveaux types de données comme les entiers ou les tableaux ont été introduits dans certains shells, ces derniers manipulent essentiellement des chaînes de caractères :
ce sont des langages de programmation orientés chaînes de caractères. C’est ce qui rend les shells à la fois si puissants et si délicats à utiliser.
L’objet de ce cours est de présenter de manière progressive les caractéristiques de bash comme langage de programmation.
-
Atouts et inconvénients des shells
L’étude d’un shell tel que bash en tant que langage de programmation possède plusieurs avantages :
- c’est un langage interprété : les erreurs peuvent être facilement localisées et traitées ; d’autre part, des modifications de fonctionnalités sont facilement apportées à l’application sans qu’il soit nécessaire de recompiler et faire l’édition de liens de l’ensemble
- le shell manipule essentiellement des chaînes de caractères: on ne peut donc construire des structures de données complexes à l’aide de pointeurs, ces derniers n’existant pas en shell. Ceci a pour avantage d’éviter des erreurs de typage et de pointeurs mal gérés. Le développeur raisonne de manière uniforme en termes de chaînes de caractères
- le langage est adapté au prototypage rapide d’applications : les tubes, les substitutions de commandes et de variables favorisent la construction d’une application par assemblage de commandes préexistantes dans l’environnement Unix
- c’est un langage « glu » : il permet de connecter des composants écrits dans des langages différents. Ces derniers doivent uniquement respecter quelques règles particulièrement simples. Le composant doit être capable :
- de lire sur l’entrée standard,
- d’accepter des arguments et options éventuels,
- d’écrire ses résultats sur la sortie standard,
- d’écrire les messages d’erreur sur la sortie standard dédiée aux messages d’erreur.
Cependant, bash et les autres shells en général ne possèdent pas que des avantages :
- issus d’Unix, système d’exploitation écrit à l’origine par des développeurs pour des développeurs, les shells utilisent une syntaxe « ésotérique » d’accès difficile pour le débutant
- l’oubli ou l’ajout d’un caractère espace provoque facilement une erreur de syntaxe
- bash possède plusieurs syntaxes pour implanter la même fonctionnalité, comme la substitution de commande ou l’écriture d’une chaîne à l’écran. Cela est principalement dû à la volonté de fournir une compatibilité ascendante avec le Bourne shell, shell historique des systèmes Unix
- certains caractères spéciaux, comme les parenthèses, ont des significations différentes suivant le contexte ; en effet, les parenthèses peuvent introduire une liste de commandes, une définition de fonction ou bien imposer un ordre d’évaluation d’une expression arithmétique. Toutefois, afin de rendre l’étude de bash plus aisée, nous n’aborderons pas sa syntaxe de manière exhaustive ; en particulier, lorsqu’il existera plusieurs syntaxes pour mettre en oeuvre la même fonctionnalité, une seule d’entre elles sera présentée.
-
Shell utilisé
La manière la plus simple de connaître le shell que l’on utilise est d’exécuter la commande unix ps qui liste les processus de l’utilisateur :
$ ps
PID TTY TIME CMD
6908 pts/4 00:00:00 bash => l’interpréteur utilisé est bash
6918 pts/4 00:00:00 ps
$
Comme il existe plusieurs versions de bash présentant des caractéristiques différentes, il est important de connaître la version utilisée. Pour cela, on utilise l'option --version de bash.
$ bash --version
GNU bash, version 3.1.14(1)-release (i486-pc-linux-gnu)
Copyright (C) 2005 Free Software Foundation, Inc.
$
Syntaxe d’une commande
La syntaxe générale d'une commande (unix ou de bash) est la suivante :
[ chemin/]nom_cmd [ option ... ] [ argument ... ]
C'est une suite de mots séparés par un ou plusieurs blancs. On appelle blanc un caractère tab (tabulation horizontale) ou un caractère espace. Un mot est une suite de caractères non blancs. Cependant, plusieurs caractères ont une signification spéciale pour le shell et provoquent la fin d'un mot : ils sont appelés méta-caractères
(exemple : |, <). Bash utilise également des opérateurs de contrôle (ex : (, ||, &&, ...) et des mots réservés pour son propre fonctionnement :
! case do done elif else esac fi fo function if in select then time until while { } [[ ]]
Bash distingue les caractères majuscules des caractères minuscules c'est-à-dire bash n'est pas égale à BAsh.
Le nom de la commande est le plus souvent le premier mot.
Une option est généralement introduite par le caractère tiret (exemple : -a) ou dans la syntaxe GNU par deux caractères tiret consécutifs (exemple : --version). Elle précise un fonctionnement particulier de la commande. La syntaxe [ elt ... ] signifie que l’élément elt est facultatif (introduit par la syntaxe [elt ]) ou bien présent une ou plusieurs fois (syntaxe elt …). Cette syntaxe ne fait pas partie du shell ; elle est uniquement descriptive (méta-syntaxe).
Les arguments désignent les objets sur lesquels doit s’exécuter la commande.
Exemple : ls -l RepC RepD : commande ls avec l’option l et les arguments RepC et RepD
Lorsque l’on souhaite connaître la syntaxe ou les fonctionnalités d’une commande cmd (exemple : ls ou bash) il suffit d’exécuter la commande man cmd (exemple : man bash). L’aide en ligne de la commande cmd devient alors disponible.
Commandes internes et externes
Le shell distingue deux sortes de commandes :
- les commandes internes
- les commandes externes.
-
Commandes internes
Une commande interne est une commande dont le code est implanté au sein de l’interpréteur de commande. Cela signifie que, lorsqu’on change de shell courant ou de connexion, par exemple en passant de bash au C-shell, on ne dispose plus des mêmes commandes internes.
Exemples de commandes internes : cd , echo , for , pwd
Sauf dans quelques cas particuliers, l’interpréteur ne crée pas de processus pour exécuter une commande interne. Les commandes internes de bash peuvent se décomposer en deux groupes :
- les commandes simples (exemple : cd, echo)
- les commandes composées (exemple : for, ((, {).
- Commandes simples
Parmi l’ensemble des commandes internes, echo est l’une des plus utilisée : elle affiche ses arguments sur la sortie standard en les séparant par un espace et va à la ligne.
Exemple :
$ echo bonjour tout le monde
affiche "bonjour tout le monde" à l'écran
Dans cet exemple, echo est invoquée avec quatre arguments : bonjour, tout, le et monde. On remarquera que les espacements entre les arguments ne sont pas conservés lors de l’affichage : un seul caractère espace sépare les mots affichés. En effet, le shell prétraite la commande, éliminant les blancs superflus.
Pour conserver les espacements, il suffit d’entourer la chaîne de caractères par une paire de guillemets :
$ echo "bonjour tout le monde"
affiche bonjour tout le monde
On dit que les blancs ont été protégés de l'interprétation du shell.
Pour afficher les arguments sans retour à la ligne, on utilise l’option -n de echo.
$ echo -n bonjour
- Commandes composées
Les commandes composées de bash sont :
case ... esac if ... fi for ... done select ... done until ... done while ... done [[ ... ]] ( ... ) { ... } (( … ))
Seuls le premier et le dernier mot de la commande composée sont indiqués. Les commandes composées sont principalement des structures de contrôle.
-
Commandes externes
Une commande externe est une commande dont le code se trouve dans un fichier ordinaire. Le shell crée un processus pour exécuter une commande externe. Parmi l’ensemble des commandes externes que l’on peut trouver dans un système, nous utiliserons principalement les commandes unix (ex : ls, mkdir, vi, sleep) et les fichiers shell. La localisation du code d'une commande externe doit être connue du shell pour qu'il puisse exécuter cette commande. A cette fin, bash utilise la valeur de sa variable prédéfinie PATH. Celle-ci contient une liste de chemins séparés par le caractère : (exemple : /bin:/usr/bin).
Par exemple, lorsque l’utilisateur lance la commande unix cal, le shell est en mesure de l’exécuter et d’afficher le calendrier du mois courant car le code de cal est situé dans le répertoire /usr/bin présent dans PATH.
Exemple :
$ cal
octobre 2015
di lu ma me je ve sa
1 2 3 4 5 6 7 8 9
10 11 12 13 14 15 16
17 18 19 20 21 22 23
24 25 26 27 28 29 30
Remarque : pour connaître le statut d’une commande, on utilise la commande interne type.
$ type sleep
sleep is /bin/sleep => sleep est une commande externe
$ type echo
echo is a shell builtin
Modes d’exécution d’une commande
Deux modes d’exécution peuvent être distingués :
- l’exécution séquentielle
- l’exécution en arrière-plan.
-
Exécution séquentielle
Le mode d’exécution par défaut d’une commande est l’exécution séquentielle : le shell lit la commande entrée par l’utilisateur, l’analyse, la prétraite et si elle est syntaxiquement correcte, l’exécute. Une fois l’exécution terminée, le shell effectue le même travail avec la commande suivante. L’utilisateur doit donc attendre la fin de l’exécution de la commande précédente pour que la commande suivante puisse être exécutée : on dit que l’exécution est synchrone.
Si on tape la suite de commandes :
sleep 3 entrée date entrée
où entrée désigne la touche entrée, l’exécution de date débute après que le délai de 3 secondes se soit écoulé. Pour lancer l’exécution séquentielle de plusieurs commandes sur la même ligne de commande, il suffit de les séparer par un caractère ;
$ cd /tmp ; pwd; echo bonjour; cd ; pwd
/tmp => affichée par l’exécution de pwd
bonjour => affichée par l’exécution de echo bonjour
/home/tony => affichée par l’exécution de pwd
$
Pour terminer l’exécution d’une commande lancée en mode synchrone, on appuie simultanément sur les touches CTRL et C.
En fait, la combinaison de touches appropriée pour arrêter l’exécution d’une commande en mode synchrone est indiquée par la valeur du champ intr lorsque la commande unix stty est lancée :
$ stty -a
speed 38400 baud; rows 24; columns 80; line = 0;
intr = ^C; quit = ^\; erase = ^?; kill = ^U; eof = ^D; eol = <undef>;
. . .
$
Supposons que la commande cat soit lancée sans argument, son exécution semblera figée à un utilisateur qui débute dans l’apprentissage d’un système Unix. Il pourra utiliser la combinaison de touches mentionnée précédemment pour terminer l’exécution de cette commande.
$ cat
^C
$
-
Exécution en arrière-plan
L’exécution en arrière-plan permet à un utilisateur de lancer une commande et de récupérer immédiatement la main pour lancer « en parallèle » la commande suivante (parallélisme logique). On utilise le caractère & pour lancer une commande en arrière-plan.
Dans l’exemple ci-dessous, la commande sleep 5 (suspendre l’exécution pendant 5 secondes) est lancée en arrière-plan. Le système a affecté le numéro d’identification 696 au processus correspondant tandis que bash a affecté un numéro de travail (ou numéro de job) égal à 1 et affiché [1]. L’utilisateur peut, en parallèle, exécuter d’autres commandes (dans cet exemple, il s’agit de la commande ps). Lorsque la commande en arrière-plan se termine, le shell le signale à l'utilisateur après que ce dernier ait appuyé sur la touche entrée.
$ sleep 5 &
[1 696 ]
$ ps
PID TTY TIME CMD
683 pts/0 00:00:00 bash
696 pts/0 00:00:00 sleep
697 pts/0 00:00:00 ps
$ => l’utilisateur a appuyé sur la touche entrée mais sleep n’était pas terminée
$ => l’utilisateur a appuyé sur la touche entrée et sleep était terminée
[1]+ Done sleep 5
$
Ainsi, outre la gestion des processus spécifique à Unix, bash introduit un niveau supplémentaire de contrôle de processus. En effet, bash permet de stopper, reprendre, mettre en arrière-plan un processus, ce qui nécessite une identification supplémentaire (numéro de job). L’exécution en arrière-plan est souvent utilisée lorsqu’une commande est gourmande en temps CPU (exemple : longue compilation d’un programme).
Les commentaires
Un commentaire débute avec le caractère # et se termine avec la fin de la ligne. Un commentaire est ignoré par le shell.
$ echo bonjour # l’ami
bonjour
$ echo coucou #l’ ami
coucou
$ # echo coucou
$
Pour que le caractère # soit reconnu en tant que début de commentaire, il ne doit pas être inséré à l’intérieur d’un mot ou terminer un mot.
$ echo il est#10 heures
il est#10 heures
$
$ echo bon# jour
bon# jour
$
Fichiers shell
Lorsqu’un traitement nécessite l’exécution de plusieurs commandes, il est préférable de les sauvegarder dans un fichier plutôt que de les retaper au clavier chaque fois que le traitement doit être lancé. Ce type de fichier est appelé fichier de commandes ou fichier shell ou encore script shell.
A l’aide d’un éditeur de texte, créer un fichier exemple contenant les lignes suivantes :
#!/bin/bash
# premier
echo -n "La date du jour est: "
date
La notation #! en première ligne d'un fichier interprété précise au shell courant quel interpréteur doit être utilisé pour exécuter le script shell (dans cet exemple, il s’agit de /bin/bash).
La deuxième ligne est un commentaire.
Vérifier le contenu de ce fichier.
$ cat premier
#!/bin/bash
#premier
echo -n "La date du jour est: "
date
$
Pour lancer l’exécution d’un fichier shell nom_fichier, on peut utiliser la commande : bash nom_fichier
$ bash exemple
la date du jour est : samedi 17 octobre 2015, 15:41:26 (UTC+0100)
$
Il est plus simple de lancer l’exécution d’un programme shell en tapant directement son nom, comme on le ferait pour une commande unix ou une commande interne.
Pour que cela soit réalisable, deux conditions doivent être remplies :
- l’utilisateur doit posséder les permissions r (lecture) et x (exécution) sur le fichier shell
- le répertoire dans lequel se trouve le fichier shell doit être présent dans la liste des
chemins contenue dans PATH (pas obligatoire).
Exemple :
$ ls -l exemple
-rw-r--r-- 1 tony-dell root 63 oct 3 15:39 exemple
$
Seule la permission r est possédée par l’utilisateur. Pour ajouter la permission x au propriétaire du fichier fichier, on utilise la commande :
chmod u+x fichier
Exemple:
$ chmod u+x exemple
$
$ ls -l exemple
-rwxr--r-- 1 tony-dell root 63 sep 3 15:39 exemple
$
maintenant on peut executer le fichier
$ ./exemple
la date du jour est : dimanche 25 octobre 2015, 15:45:28 (UTC+0200)
$