Skip to content
Snippets Groups Projects

Semi adv

Merged Stephane Bonnet requested to merge semi-adv into master
1 file
+ 1098
22
Compare changes
  • Side-by-side
  • Inline
+ 1098
22
\subsection{Wildcards et globs}
\subsection{Globbing patterns et wildcards}
\begin{frame}[fragile]{Faire référence à plusieurs fichiers}
%% globs
%% Attention aux fichiers cachés
C'est fastidieux d'être obligé d'écrire le nom de tous les fichiers dans
les commandes. On peut se simplifier la vie grâce aux globbing patterns.
\begin{block}{globbing pattern (\emph{motif d'englobement})}
Un motif de nom de fichier qui en englobe plusieurs.
\end{block}
\begin{block}{wildcard (\emph{joker})}
Lettre spéciale qui représente un caractère ou une suite de caractères
quelconques dans un \emph{globbing pattern}.
\end{block}
\end{frame}
\begin{frame}[fragile]{Le joker ``*''}
Joker le plus utilisé.
Remplace toute suite de caractères dans un motif. S'il est utilisé seul, remplace tout mot.
\begin{exampleblock}{Créons des fichiers}
\cmd{cd ; mkdir api ; cd api}
\cmd{touch here that there this}
\end{exampleblock}
\begin{alertblock}{Le point-virgule}
Le point virgule sépare des commandes successives sur la ligne de commande.
\end{alertblock}
\begin{alertblock}{\cmd{touch}}
Crée les fichiers passés en arguments. Si un fichier existe déjà,
met à jour sa date de dernière modification.
\end{alertblock}
\end{frame}
\begin{frame}[fragile]{Le joker ``*''}
\begin{exampleblock}{Supprimons des fichiers}
On pourrait écrire: \cmd{rm here that there this}
\cmd{rm *} fait la même chose car le joker ``*'' correspond à tous les noms de fichiers.
\end{exampleblock}
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ ls
here that there this
$ \textcolor{yellow}{rm *}
$ ls
$
\end{Verbatim}
\end{beamercolorbox}
\end{frame}
\begin{frame}[fragile]{Le joker ``*''}
\begin{exampleblock}{Re-créeons des fichiers}
\cmd{touch here that there this}
\end{exampleblock}
On peut restreindre le motif en donnant une partie du nom.
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ ls *
here that there this
$ ls t*
that there this
$ ls *h*
here that there this
$ ls th*e
there
$ ls that*
that
$ ls thi*s
this
\end{Verbatim}
\end{beamercolorbox}
\begin{alertblock}{Attention}
``*'' correspond aussi aux séquences vides!
\end{alertblock}
\end{frame}
\begin{frame}[fragile]{Le joker ``?''}
\begin{block}{}
Il représente un caractère unique quelconque dans un motif.
\end{block}
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ ls th?t
that
$ ls th??
that this
$ ls th???
there
$ ls ?here
there
$ ls *here \textcolor{red}{<---- Attention ici le joker correspond aussi à une séquence vide}
here there
\end{Verbatim}
\end{beamercolorbox}
\end{frame}
\begin{frame}[fragile]{Le joker ``[]''}
\begin{block}{}
Permet de définir un ensemble de caractères pouvant apparaître dans le nom.
\end{block}
\begin{exampleblock}{Créons plus de fichiers}
\cmd{touch file\_1 file\_2 file\_3 file\_4 file\_a file\_b file\_c file\_d}
\end{exampleblock}
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ ls file_[12ab]
file_1 file_2 file_a file_b
\end{Verbatim}
\end{beamercolorbox}
\end{frame}
\begin{frame}[fragile]{Le joker ``[]''}
On peut spécifier des intervalles plutôt que de donner tous les caractères.
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ ls file_[1-3b-d]
file_1 file_2 file_3 file_b file_c file_d
\end{Verbatim}
\end{beamercolorbox}
\vspace{10pt}
On peut aussi prendre le complément de la liste en la préfixant par un ``\verb+^+''.
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ ls file_[^1-3b-d]
file_4 file_a
\end{Verbatim}
\end{beamercolorbox}
\end{frame}
\begin{frame}[fragile]{Échappement de caractères}
Et si il y a un fichier dont le nom contient le caractère ``-''?
\begin{exampleblock}{Un fichier de plus}
\cmd{touch file\_-}
\end{exampleblock}
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ ls file_[1-3b-d]
file_1 file_2 file_3 file_b file_c file_d
$ ls file_[1-3b-d\textcolor{yellow}{\textbackslash{}-}]
file_- file_1 file_2 file_3 file_b file_c file_d
\end{Verbatim}
\end{beamercolorbox}
\vspace{10pt}
\begin{block}{Caractère d'échappement}
Le caractère ``\textbackslash'' supprime l'interprétation par le shell du caractère qui le suit.
On peut même échapper l'espace.
\end{block}
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ touch my\textbackslash file
$ ls
'my file' \textcolor{cyan}{<----- Les simple quotes indiquent qu'il s'agit d'un seul fichier}
\end{Verbatim}
\end{beamercolorbox}
\end{frame}
\begin{frame}[fragile]{Expansion d'accolades}
\begin{block}{Expansion d'accolades}
\cmd{bash} supporte l'expansion d'accolades: générer toutes les chaînes dans un intervalle ou à partir
d'une liste.
\end{block}
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ echo \{1..20\}
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
$ echo a\{c,d,e\}f
acf adf aef
\end{Verbatim}
\end{beamercolorbox}
\vspace{10pt}
Cette expansion peut être utilisée dans des motifs.
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ touch file_\{1..20\}
$ ls
file_1 file_12 file_15 file_18 file_20 file_5 file_8
file_10 file_13 file_16 file_19 file_3 file_6 file_9
file_11 file_14 file_17 file_2 file_4 file_7
$ rm file_\{12..14\}
$ ls
file_1 file_15 file_18 file_20 file_5 file_8
file_10 file_16 file_19 file_3 file_6 file_9
file_11 file_17 file_2 file_4 file_7
\end{Verbatim}
\end{beamercolorbox}
\end{frame}
\begin{frame}[fragile]{Expansion d'accolades}
\begin{block}{Extensions multiples}
L'expansion d'accolade est très utilisée pour sélectionner des fichiers avec des extensions multiples.
\cmd ls *.\{jpg,png,bmp\}
listera tous les fichiers correspondants à ces extensions.
\end{block}
\begin{alertblock}{Extensions}
\begin{itemize}
\item Les extensions n'ont pas de sens particulier sous UNIX.
\item Spécificité de Windows et de ses prédécesseurs.
\item Pratique pour indiquer le type des fichiers...
\end{itemize}
\end{alertblock}
\end{frame}
\begin{frame}[fragile]{Remarques}
\begin{block}{Jokers dans les chemins}
Le chemin fait partie du nom des fichiers, on peut mettre des jokers dans ceux-ci.
\cmd{ls /var/*/*.log}
liste tous les fichiers de logs dans tous les sous-répertoires directs de \cmd{/var}
\cmd{ls /var/*/*/*.log}
liste tous les fichiers de logs dans tous les sous-répertoires des sous-répertoires de \cmd{/var}
\end{block}
\begin{block}{Si le motif ne correspond à aucun fichier?}
Dans ce cas, le motif est transmis tel quel à la commande.
\end{block}
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ rm file?
rm: impossible de supprimer 'file?': Aucun fichier ou dossier de ce type
\end{Verbatim}
\end{beamercolorbox}
\end{frame}
\begin{frame}[fragile]{Remarques}
\begin{alertblock}{Attention aux noms pris comme des options}
On suppose qu'il existe un fichier ``-R''.
Si on exécute ``\cmd{rm *}'', l'englobement va passer le nom \cmd{-R} à ``\cmd{rm}'' qui l'interprétera comme une option.
La commande réellement exécutée sera ``\cmd{rm -R *}''. Oups!
\end{alertblock}
\begin{block}{Séparer les options des arguments}
\begin{itemize}
\item ``\cmd{-{}-}'' est utilisé dans les commandes pour séparer explicitement les options des arguments.
\item Tout ce qui suit ``\cmd{-{}-}'' est interprété comme un argument.
\end{itemize}
``\cmd{rm -{}- *}'' est donc plus sûr, puisque c'est bien la commande ``\cmd{rm -{}- -R *}'' qui sera exécutée.
\end{block}
\end{frame}
\begin{frame}[fragile]{Et les fichiers cachés?}
%% globs
%% Attention aux fichiers cachés
\begin{block}{Des fichiers cachés? Où ça?}
Tous les fichiers dont le nom commence par un point sont cachés.
\begin{itemize}
\item Ils ne sont pas affichés par ``\cmd{ls}''.
\item Ils ne sont pas considérés pour l'englobement.
\end{itemize}
\end{block}
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ touch .hidden
$ ls
$ ls -a
\textcolor{blue}{.} \textcolor{blue}{..} .hidden
$ rm *
$ ls -a
\textcolor{blue}{.} \textcolor{blue}{..} .hidden
\end{Verbatim}
\end{beamercolorbox}
\end{frame}
\begin{frame}[fragile]{Et les fichiers cachés?}
\begin{alertblock}{\cmd{shopt}}
\cmd{shopt} permet de changer certaines options du shell.
\begin{itemize}
\item \cmd{shopt -s <option>} active l'option \cmd{<option>}
\item \cmd{shopt -u <option>} active l'option \cmd{<option>}
\end{itemize}
\end{alertblock}
\begin{block}{L'option \cmd{dotglob}}
Si elle est active, les fichiers commençant par un point sont candidats à l'englobement. Par défaut désactivée.
\end{block}
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ ls -a
\textcolor{blue}{.} \textcolor{blue}{..} .hidden
$ \textcolor{yellow}{shopt -s dotglob}
$ rm *
$ ls -a
\textcolor{blue}{.} \textcolor{blue}{..}
\end{Verbatim}
\end{beamercolorbox}
\end{frame}
\subsection{Chercher des fichiers}
\begin{frame}{Trouver des fichiers}
Des centaines de milliers de fichiers sur une distribution classique.
Difficile de s'y retrouver sans outils...
\begin{block}{\cmd{locate}}
Recherche des fichiers dans une base de données préremplie
\end{block}
\begin{block}{\cmd{find}}
Recherche des fichiers dans l'arborescence, éventuellement avec des filtres
précis.
\end{block}
\end{frame}
\begin{frame}[fragile]{\cmd{locate}}
%% find
%% Exécution de commandes
\begin{block}{}
\begin{description}
\item[\cmd{locate <motif>}] recherche \cmd{<motif>} dans la base de données \cmd{/var/lib/mlocate/mlocate.db}
\end{description}
\end{block}
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ locate issue
/etc/issue
/etc/issue.net
[...]
\end{Verbatim}
\end{beamercolorbox}
\begin{alertblock}{Si \cmd{locate} ne renvoie rien}
\begin{itemize}
\item Rien n'a été trouvé
\item La base de donnée est vide
\end{itemize}
\end{alertblock}
\end{frame}
\begin{frame}[fragile]{\cmd{updatedb}}
\begin{block}{}
\begin{description}
\item[\cmd{updatedb}] met à jour la base de données \cmd{/var/lib/mlocate/mlocate.db}
\end{description}
\end{block}
\begin{alertblock}{\cmd{sudo} obligatoire!}
Cette commande modifie un fichier que seul le superutilisateur peut modifier.
Il faut exécuter \cmd{sudo updatedb}.
\end{alertblock}
\begin{alertblock}{\cmd{sudo} (\emph{SuperUserDO})}
\begin{itemize}
\item Cette commande exécute une autre commande avec les droits du superutilisateur.
\item Seuls certains utilisateurs ont le droit de l'invoquer.
\item Elle demande le mot de passe de l'utilisateur qui l'invoque avant de s'exécuter.
\end{itemize}
\end{alertblock}
\end{frame}
\begin{frame}[fragile]{\cmd{find}}
\begin{block}{}
\begin{description}
\item[\cmd{find}] recherche un fichier dans le système de fichiers.
\end{description}
\end{block}
Il suffit de spécifier le point de départ et ce qu'on cherche.
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ find . -name file_1
./api/file_1
\end{Verbatim}
\end{beamercolorbox}
On peut utiliser des jokers dans le nom
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ find . -name 'file_1*' -print
./api/file_11
./api/file_18
./api/file_1
[...]
\end{Verbatim}
\end{beamercolorbox}
\begin{alertblock}{Attention aux quotes}
Le motif doit être entre quotes, sinon il sera interprété par le
shell.
\end{alertblock}
\end{frame}
\begin{frame}[fragile]{Filtrer avec \cmd{find}}
\begin{block}{}
\cmd{find} est capable de filtrer la recherche
\begin{itemize}
\item{Par type de fichier}
\item{Par taille}
\item{Par date de modification}
\item ...
\end{itemize}
\end{block}
\begin{exampleblock}{Cherchons les fichiers de plus de 10 Mo}
\cmd{find / -size +10M -print}
\end{exampleblock}
\begin{alertblock}{Il y a plein d'erreurs!}
Elles sont dûes au permissions d'accès à certains fichiers.
On peut les supprimer en redirigeant la sortie d'erreur vers
le périphérique 'poubelle' \cmd{/dev/null}:
\cmd{find / -size +10M -print 2> /dev/null}
\end{alertblock}
\end{frame}
\begin{frame}[fragile]{Exécuter des commandes avec \cmd{find}}
\cmd{find} peut exécuter une commande sur chaque fichier trouvé
avec l'option \cmd{-exec}.
\begin{exampleblock}{Créer un backup de chaque fichier}
\cmd{find api -name 'file*' -exec cp \{\} \{\}.bak \textbackslash;}
\end{exampleblock}
\begin{block}{Explication}
\begin{itemize}
\item \cmd{cp}] est exécutée pour chaque fichier trouvé
\item \cmd{\{\}} est remplacé par le nom du fichier trouvé
\item \cmd{\textbackslash;} indique la fin de la commande.
\end{itemize}
\end{block}
\begin{alertblock}{}
\begin{itemize}
\item \cmd{-exec} n'autorise qu'une seule commande.
\item On peut avoir plusieurs \cmd{-exec}.
\end{itemize}
\end{alertblock}
\end{frame}
\subsection{Chercher à l'intérieur des fichiers}
\begin{frame}[fragile]{\cmd{grep}}
\begin{block}{}
\begin{description}
\item[\cmd{grep}] recherche un motif dans des fichiers
\end{description}
\end{block}
\begin{exampleblock}{Chercher tous les mots qui contiennent ``aard''}
\cmd{grep 'aard' /usr/share/dict/words}
\end{exampleblock}
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ grep 'aard' /usr/share/dict/words
Kierkeg\textcolor{red}{aard}
Kierkeg\textcolor{red}{aard}'s
\textcolor{red}{aard}vark
\textcolor{red}{aard}vark's
\textcolor{red}{aard}varks
\end{Verbatim}
\end{beamercolorbox}
\begin{block}{Remarques}
\begin{itemize}
\item{\cmd{grep} peut être utilisée récursivement:
option \cmd{-R}}
\item{\cmd{grep} sans argument, cherche le motif sur l'entrée
standard}
\end{itemize}
\end{block}
\end{frame}
\begin{frame}[fragile]{Expressions régulières}
\begin{frame}[fragile]{Expressions régulières (\emph{regex})}
\begin{block}{}
\begin{itemize}
\item Chaîne de caractères qui décrit précisément un ensemble
de chaînes de caractères possibles.
\item Dans les commandes qui utilisent un motif (comme \cmd{grep}), le motif est presque toujours une expression régulière.
\end{itemize}
\end{block}
\end{frame}
\begin{frame}[fragile]{Expressions régulières (\emph{regex})}
\framesubtitle{Bases}
\begin{itemize}
\item Décrit la suite de caractères qui doivent correspondre dans une chaîne.
\item Les alternatives sont séparées par une barre verticale: \cmd{a|b} reconnaît tout
mot contenant 'a' ou 'b'.
\item Les parenthèses regroupent les expressions:
\begin{itemize}
\item \cmd{ab|cd} reconnaît tout mot contenant 'ab' ou 'cd'
\item \cmd{a(b|c)d} reconnaît tout mot contenant 'abd' ou 'acd'.
\end{itemize}
\end{itemize}
\begin{alertblock}{Attention aux caractères interprétés par le shell}
Les parenthèses et les barres verticales sont interprétées par le shell.
Il faut les échapper pour les utiliser dans des regex. Pour exploiter le motif
\cmd{a(b|c)d} avec grep, il faudra écrire:
\begin{center}
\cmd{grep 'a\textbackslash(b\textbackslash|c\textbackslash)d'}
\end{center}
\end{alertblock}
\end{frame}
\begin{frame}[fragile]{Expressions régulières (\emph{regex})}
\framesubtitle{Caractères}
Chaque caractère de la chaîne à reconnaître doit être spécifié, soit en donnant sa valeur
directement ou en donnant sa classe.
\begin{itemize}
\item \cmd{abcd} : la suite 'abcd'.
\item \cmd{[ab]bcd} : soit a, soit b suivi de bcd. Les crochets définissent une
classe de caractères acceptables pour un caractère donné.
\item \cmd{[a-z]bcd} : on peut utiliser des intervalles dans les classes.
\item \cmd{a.b} : trois caractères commençant par a et finissant par b.
Le point correspond à n'importe quel caractère.
\item \cmd{[:alnum:]} : tout caractère alphanumérique
\item \cmd{[:digit:]} : tout chiffre
\item \cmd{[:space:]} : tout espace
\end{itemize}
\end{frame}
\begin{frame}[fragile]{Expressions régulières (\emph{regex})}
\framesubtitle{Quantificateurs et prédicats}
Il représentent le nombre de répétitions d'une expression et ajoutent des contraintes sur
sa position dans la chaîne.
\begin{itemize}
\item \cmd{expr*} : le motif \cmd{expr} répété 0 ou plusieurs fois.
\item \cmd{expr+} : le motif \cmd{expr} répété 1 ou plusieurs fois.
\item \cmd{expr?} : le motif \cmd{expr} répété 0 ou une fois.
\item \verb+^expr+ : le motif \cmd{expr} en début de ligne.
\item \cmd{expr\$} : le motif \cmd{expr} en fin de ligne.
\end{itemize}
\end{frame}
\begin{frame}[fragile]{\cmd{grep} et expressions régulières}
\begin{exampleblock}{Trouver tous les mots commençant par ab}
\verb+grep '^ab' /usr/share/dict/words+
\end{exampleblock}
\begin{exampleblock}{Trouver tous les mots de quatre lettres commençant par g et finissant par t}
\verb+grep '^g..t$' /usr/share/dict/words+
\end{exampleblock}
\begin{exampleblock}{Trouver tous les mots commençant par g et finissant par t}
\verb,grep '^g.\+t$' /usr/share/dict/words,
\end{exampleblock}
\begin{alertblock}{C'est très pratique...}
...pour les mots croisés!
\end{alertblock}
\end{frame}
\subsection{Identifier des fichiers}
\begin{frame}[fragile]{\cmd{file}}
\begin{block}{}
\begin{description}
\item[\cmd{file}] identifie la nature des données d'un fichier.
\end{description}
\end{block}
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ file /usr/lib/libreoffice/program/intro.png
/usr/lib/libreoffice/program/intro.png: PNG image data, 661 x 169, 8-bit/color RGBA, interlaced
$ file /bin/bash
/bin/bash: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked,
interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 3.2.0,
BuildID[sha1]=b636f50d85c3cca7cf2518030446660c1d90d660, stripped
\end{Verbatim}
\end{beamercolorbox}
\begin{block}{Remarque}
\cmd{file} fonctionne en analysant réellement le contenu du fichier, il ne se sert pas de
l'extension.
\end{block}
\end{frame}
\subsection{Manipuler des fichiers}
\begin{frame}[fragile]{Un peu de manipulation de fichiers}
%% cut
%% sort
%% wc
%% diff
Il existe de nombreuses commandes de manipulation de fichiers utiles:
\begin{description}
\item[\cmd{wc}] Compte les lignes, mots, etc. d'un fichier
\item[\cmd{sort}] Trie les lignes d'un fichier
\item[\cmd{uniq}] Supprime les doublons adjacents d'un fichier
\item[\cmd{tr}] Transforme les caractères d'un fichier
\item[\cmd{diff}] Compare deux fichiers et affiche les différences
\item[\cmd{cut}] Découpe un fichier en champs
\item[\cmd{sed}] Édite un fichier à la volée
\end{description}
\end{frame}
\begin{frame}[fragile]{\cmd{tr}}
\begin{block}{}
\begin{description}
\item[\cmd{tr}] Transforme des caractères entre deux ensembles
\end{description}
\end{block}
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ cd ~/api ; echo 'The quick brown fox jumps over the lazy dog' > file.txt
\end{Verbatim}
\end{beamercolorbox}
\begin{columns}
\begin{column}{.45\textwidth}
Un peu de cryptographie...
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ \textcolor{yellow}{tr 'a-z' 'b-za' < file.txt}
Tif rvjdl cspxo gpy kvnqt pwfs uif mbaz eph
\end{Verbatim}
\end{beamercolorbox}
Passage en capitales...
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ \textcolor{yellow}{tr [:lower:] [:upper:] < file.txt}
THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG
\end{Verbatim}
\end{beamercolorbox}
\end{column}
\begin{column}{.45\textwidth}
Séparons les mots...
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ \textcolor{yellow}{tr [:blank:] '\textbackslash{}n' < file.txt}
The
quick
brown
fox
jumps
over
the
lazy
dog
\end{Verbatim}
\end{beamercolorbox}
\end{column}
\end{columns}
\begin{alertblock}{Séquences d'échappement}
Interprétées par le shell comme des caractères spéciaux: \cmd{\textbackslash{}n} est un retour à la ligne, \cmd{\textbackslash{}t} une
tabulation...
\end{alertblock}
\end{frame}
\begin{frame}[fragile]{\cmd{cut}}
\begin{block}{}
\begin{description}
\item[\cmd{cut}] Supprime des sections de chaque ligne d'un fichier.
\end{description}
\end{block}
\begin{columns}
\begin{column}{.45\textwidth}
On garde les caractères 5 à 9...
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ \textcolor{yellow}{cut -c 5-9 file.txt }
quick
\end{Verbatim}
\end{beamercolorbox}
\end{column}
\begin{column}{.45\textwidth}
On garde les champs 3 et 5...
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ \textcolor{yellow}{cut -f 3,5 -d' ' file.txt}
brown jumps
\end{Verbatim}
\end{beamercolorbox}
\end{column}
\end{columns}
\begin{alertblock}{Délimiteur}
Le délimiteur de champs est par défaut la tabulation. L'option \cmd{-d} permet de le changer.
\end{alertblock}
\end{frame}
\begin{frame}[fragile]{\cmd{sed}}
\begin{block}{}
\begin{description}
\item[\cmd{sed}] (\emph{Stream EDitor}) Édite le fichier ligne par ligne à la volée.
\end{description}
\end{block}
Remplaçons \emph{brown} par \emph{yellow}...
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ \textcolor{yellow}{sed 's/brown/yellow/g' file.txt }
The quick yellow fox jumps over the lazy dog
\end{Verbatim}
\end{beamercolorbox}
\begin{itemize}
\item \cmd{s} est la commande de remplacement. Elle prend deux paramètres:
\begin{itemize}
\item le motif à rechercher (c'est une regex)
\item le texte à substituer aux correspondances
\end{itemize}
\item \cmd{g} indique que le remplacement affecte toutes les occurrences.
\item Le séparateur est le caractère qui suit directement la commande \cmd{s}.
On aurait pu utiliser un autre caractère que ``/''.
\end{itemize}
\begin{alertblock}{RTFM}
\cmd{sed} est une commande très puissante mais très complexe. Lisez le man.
\end{alertblock}
\end{frame}
\subsection{Combiner les commandes: les pipes}
\begin{frame}[fragile]{Pipes}
\begin{frame}[fragile]{Les Pipes}
\framesubtitle{Généralités}
\begin{alertblock}{KISS (Keep It Simple, Stupid)}
Les commandes, aussi complexes qu'elles soient, sont chacune spécialisées dans une
fonction spécifique. C'est la philosophie générale des commandes Unix: ne faire qu'une
chose, mais la faire bien.
\end{alertblock}
\begin{block}{Les pipes (ou tubes)}
\begin{itemize}
\item Connectent la sortie standard d'une commande à l'entrée standard d'une autre.
\item Permettent de chaîner des commandes pour construire des traitements complexes.
\end{itemize}
\end{block}
\end{frame}
\begin{frame}[fragile]{Les Pipes}
\framesubtitle{Comment ça marche?}
Supposons qu'on veuille voir le listing complet des fichiers du système. On peut
exécuter ``\cmd{ls -lR /}'' mais la sortie est trop grande et on ne pourra pas tout voir...
On peut utiliser les services de \cmd{less} pour paginer la sortie.
Il suffit de taper:
\begin{exampleblock}{}
\cmd{ls -lR / | less}
\end{exampleblock}
Le symbole ``|'' représente le pipe entre les deux commandes.
\end{frame}
\begin{frame}[fragile]{Les Pipes}
\framesubtitle{Remarques}
\begin{itemize}
\item Les pipes ne sont pas de taille infinie. Les commandes qui produisent
les données (ici \cmd{ls}) attendent lorsqu'ils sont pleins. \textbf{On ne peut pas perdre
de données dans un pipe.}
\item Si on arrête le consommateur (ici \cmd{less}), le producteur se termine également
par fermeture de son fichier de sortie standard.
\item De même, la fin du producteur entraine la fermeture de l'entrée standard du
consommateur et donc son arrêt.
\end{itemize}
\end{frame}
\begin{frame}[fragile]{\cmd{tee}}
\begin{frame}[fragile]{Les Pipes}
\framesubtitle{La commande \cmd{tee}}
On peut vouloir enregistrer la sortie d'une commande dans un fichier en même temps
qu'on la transmet à une autre commande par un pipe.
\begin{block}{\cmd{tee}}
\begin{description}
\item[\cmd{tee}] lit son entrée standard, l'enregistre dans un fichier et
la recopie sur sa sortie standard.
\end{description}
\end{block}
\begin{exampleblock}{Enregistrer la sortie de \cmd{ls -lR} pendant qu'on compte les fichiers}
\verb+ls -lR ~ | tee listing.txt | wc -l+
\end{exampleblock}
\end{frame}
\begin{frame}[fragile]{Les Pipes}
\framesubtitle{A vous de jouer!}
\begin{itemize}
\item Téléchargez ``Vingt mille lieues sous les mers'' de Jules VERNE depuis le site du
projet Gutemberg:
\end{itemize}
\begin{exampleblock}{}
\cmd{wget http://www.gutenberg.org/files/54873/54873-0.txt}
\end{exampleblock}
\begin{exampleblock}{Combien de mots différents sont utilisés par l'auteur?}
Il faut: lire le fichier, le transformer pour qu'il ait un mot par ligne, trier les mots,
éliminer les mots en double ou plus, compter le nombre de lignes.
\end{exampleblock}
\begin{exampleblock}{Combien de fois le Capitaine Nemo est-il nommé?}
L'approche est similaire, mais il faut aussi ne garder que le mot ``Nemo''.
\end{exampleblock}
\end{frame}
\subsection{Processus et jobs}
\begin{frame}[fragile]{Les processus}
\framesubtitle{Définition}
\begin{block}{Qu'est-ce que c'est?}
\begin{itemize}
\item Un processus est un programme en cours d'exécution.
\item Un programme est un exécutable binaire stocké sur le disque dans un fichier
\item A son exécution, le programme est copié en mémoire par le système et
devient un processus.
\item De nombreux processus s'exécutent en même temps: c'est une des fonctions
principales du système de partager le processeur et la mémoire entre ceux-ci.
\end{itemize}
\end{block}
\end{frame}
\begin{frame}[fragile]{Mettre fin à des processus}
\begin{frame}[fragile]{Les processus}
\framesubtitle{Hierarchie des processus}
\begin{block}{PID}
Les processus sont identifiés par in nombre: l'identifiant du processus,
ou \emph{Process ID (PID)}.
\end{block}
\begin{block}{Arborescence des processus}
Un processus a un père unique: c'est le processus qui l'a créé. L'ID du
processus père est le \emph{Parent Process ID (PPID)}.
\end{block}
\begin{block}{Processus initial}
Le premier processus est exécuté directement par le noyau au démarrage. Il s'agit du
processus \cmd{init} (\cmd{systemd} sur Ubuntu). Son PID est 0 et il est l'ancêtre de
tous les processus.
\end{block}
\end{frame}
\begin{frame}[fragile]{Les processus}
\framesubtitle{État des processus}
A tout instant, un processus est dans l'un des états suivants:
\begin{itemize}
\item R (Running): Processus éligible au processeur
\item S (Sleeping): Processus en attente d'un événement
\item D (Uninterruptible Sleep): Processus en attente d'une entrée / sortie
\item T (Stopped): Processus interrompu par un signal de contrôle
\item Z (Zombie): Terminé, en attente du processus père
\end{itemize}
% \begin{center}
% \begin{tabular}{|m{1cm}|m{3cm}|m{5.5cm}|}
% \hline
% \textbf{Lettre} & \textbf{Signification} & \textbf{Description} \\
% \hline\hline
% R & Running & Processus éligible au processeur \\
% \hline
% S & Sleeping & Processus en attente d'un événement \\
% \hline
% D & Uninterruptible Sleep & Processus en attente d'une entrée / sortie \\
% \hline
% T & Stopped & Processus interrompu par un signal de contrôle \\
% \hline
% Z & Zombie & Terminé, en attente du processus père \\
% \hline
% \end{tabular}
% \end{center}
\end{frame}
\begin{frame}[fragile]{Les processus}
\framesubtitle{Voir les processus}
\begin{block}{\cmd{ps}}
\begin{description}
\item[\cmd{ps}] affiche les processus en cours d'exécution et les informations associées
\end{description}
\end{block}
\cmd{ps} seul affiche tous les processus de l'utilisateur associé au terminal:
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ ps
PID TTY TIME CMD
10923 pts/2 00:00:01 bash
12472 pts/2 00:00:00 cat
12622 pts/2 00:00:00 ps
\end{Verbatim}
\end{beamercolorbox}
Il y a ici trois processus. Les champs s'interprètent comme suit:
\begin{description}
\item[PID] Le PID
\item[TTY] Le terminal de contrôle
\item[TIME] Le temps réellement passé à utiliser le processeur
\item[CMD] La commande exécutée
\end{description}
\end{frame}
\begin{frame}[fragile]{Les processus}
\framesubtitle{Voir les processus}
La commande ``\cmd{ps a}'' affiche tous les processus de l'utilisateur.
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ ps a
PID TTY STAT TIME COMMAND
986 tty1 Ssl+ 0:00 /usr/lib/gdm3/gdm-x-session --run-script env GNOME_S
988 tty1 Sl+ 21:46 /usr/lib/xorg/Xorg vt1 -displayfd 3 -auth /run/user/
999 tty1 Sl+ 0:00 /usr/lib/gnome-session/gnome-session-binary --sessio
1163 tty1 Sl+ 41:15 /usr/bin/gnome-shell
1208 tty1 Sl 14:18 ibus-daemon --xim --panel disable
1212 tty1 Sl 0:00 /usr/lib/ibus/ibus-dconf
[...]
\end{Verbatim}
\end{beamercolorbox}
\medskip
La commande ``\cmd{ps aux}'' affiche tous les processus de tous les utilisateurs.
\end{frame}
\begin{frame}[fragile]{Les processus}
\framesubtitle{Voir les processus}
\begin{block}{\cmd{pstree}}
La commande \cmd{pstree} affiche l'arbre des processus en cours d'exécution/
\end{block}
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ pstree -A
systemd-+-ModemManager---2*[{ModemManager}]
|-NetworkManager-+-dhclient
| `-2*[{NetworkManager}]
|-2*[VBoxClient---VBoxClient]
|-2*[VBoxClient---VBoxClient---{VBoxClient}]
|-VBoxClient---VBoxClient---2*[{VBoxClient}]
|-VBoxService---7*[{VBoxService}]
|-accounts-daemon---2*[{accounts-daemon}]
|-acpid
|-avahi-daemon---avahi-daemon
|-boltd---2*[{boltd}]
|-colord---2*[{colord}]
|-cron
[...]
\end{Verbatim}
\end{beamercolorbox}
\begin{alertblock}{}
\cmd{systemd} est bien l'ancêtre de tout les processus...
\end{alertblock}
\end{frame}
\begin{frame}[fragile]{Les processus}
\framesubtitle{Suivre les processus en temps réel}
\begin{block}{\cmd{top}, \cmd{htop}}
\begin{itemize}
\item \cmd{top} affiche l'évolution des processus en temps réel. Quitter avec ``q''.
\item \cmd{htop} fait la même chose avec une interface plus moderne.
\end{itemize}
Ces deux commandes montrent aussi en temps réel l'utilisation des processeurs et
l'occupation de la mémoire. Elles permettent de suivre les performances du système.
\end{block}
\end{frame}
\begin{frame}[fragile]{Les processus}
\framesubtitle{Les signaux}
\begin{block}{Signal}
Le noyau peut transmettre des signaux aux processus pour des raisons diverses.
Les processus peuvent intercepter certains de ces signaux. S'il ne le font pas, alors
les signaux ont des effets par défaut sur le processus.
\end{block}
\begin{block}{Transmission de signaux par le clavier}
Quand un processus est exécuté au premier plan, certaines combinaisons de touches
provoquent la transmission de signaux vers celui-ci.
\begin{itemize}
\item \cmd{CTRL+C} envoie SIGINT. Met fin au processus avec potentielle perte de données.
\item \cmd{CTRL+Z} envoie SIGTSTP. Stoppe le processus et rend la main au shell.
\item \cmd{CTRL+]} envoie SIGQUIT. Met fin au processus plus brutalement que \cmd{CTRL+C}.
\end{itemize}
\end{block}
\end{frame}
\begin{frame}[fragile]{Terminaux}
\begin{frame}[fragile]{Les processus}
\framesubtitle{Effet des signaux}
\begin{exampleblock}{CTRL+C vs. CTRL+]}
\begin{itemize}
\item Installez \cmd{sl}: \cmd{sudo apt install sl}
\item Lancer sl. Le train passe.
\item Observez la différence entre CTRL+C et CTRL+] pendant le passage du train.
\end{itemize}
\end{exampleblock}
\end{frame}
\begin{frame}[fragile]{Exécution en arrière plan}
Une commande exécutée en arrière plan est dite \emph{détachée} du terminal.
\begin{block}{Exécution en arrière plan}
Faire suivre la commande de ``\&''. La commande se lance et rend la main au shell.
``\cmd{gedit \&}'' lance l'éditeur de texte gedit et rend la main.
\end{block}
\begin{block}{Arrière plan et signaux}
\cmd{CTRL+Z} suspend le processus attaché au terminal.
``\cmd{bg}'' le relance en arrière plan, comme si on l'avait exécuté avec ``\&''.
\end{block}
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ xeyes
^Z
[1]+ Arrêté xeyes
$ \textcolor{yellow}{bg}
[1]+ xeyes &
$
\end{Verbatim}
\end{beamercolorbox}
\end{frame}
\begin{frame}[fragile]{Mettre fin à des processus}
\begin{block}{\cmd{kill}}
Pour mettre fin à un processus, la commande à utiliser est \cmd{kill} suivie du PID du processus à tuer.
\end{block}
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ ps
PID TTY TIME CMD
13154 pts/5 00:00:00 bash
\textcolor{yellow}{13162} pts/5 00:00:01 xeyes
13178 pts/5 00:00:00 ps
$ kill \textcolor{yellow}{13162}
$
[1]+ Complété xeyes
$
\end{Verbatim}
\end{beamercolorbox}
\begin{alertblock}{Processus récalcitrants}
Par défaut, \cmd{kill} envoie \cmd{SIGTERM} au processus. Si le processus ne se termine pas avec
ce signal,
``\cmd{kill -KILL}'' (ou ``\cmd{kill -9}'') suivie du PID y mettra fin systématiquement mais avec plus de
risques de perte de données.
\end{alertblock}
\end{frame}
\begin{frame}[fragile]{Gestion des jobs}
\begin{itemize}
\item \cmd{jobs} affiche la liste des processus en arrière plan
\item \cmd{fg} ramène le processus indiquer en avant plan
\item \cmd{bg} passe le dernier processus arrêté en arrière plan
\item \cmd{kill} peut aussi s'utiliser avec un numéro de job.
\end{itemize}
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ xeyes &
[1] 13507
$ jobs
[\textcolor{yellow}{1}]+ En cours d'exécution xeyes &
$ kill \textcolor{yellow}{%1}
$
[1]+ Complété xeyes
$
\end{Verbatim}
\end{beamercolorbox}
\end{frame}
\subsection{Substitution de commandes}
\begin{frame}[fragile]{Substitution de commandes}
Consiste à récupérer la sortie d'une commande pour remplacer le texte de la commande.
\begin{block}{Syntaxe de la substitution de commande}
Deux syntaxes sont possibles:
\begin{itemize}
\item \cmd{\$( commande )}
\item \cmd{` commande `}
\end{itemize}
\end{block}
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ echo Nous sommes le \textcolor{yellow}{$(date +'%A %d %B %Y').}
Nous sommes le mardi 22 janvier 2019.
\end{Verbatim}
\end{beamercolorbox}
\end{frame}
\subsection{L'historique}
\begin{frame}[fragile]{Rappeler des commandes}
%% Historique + manipulation
%% Où est l'historique (bases)
\cmd{bash} maintient un historique des commandes et permet de les rappeler pour ne pas avoir à les retaper.
L'historique est stocké
dans le fichier \verb+~/.bash\_history+.
\begin{itemize}
\item La commande ``\cmd{history}'' affiche l'historique.
\item Les touches haut et bas permettent de naviguer dans l'historique.
\item Le point d'exclamation suivi d'une chaîne rappelle la dernière commande commençant par cette chaîne.
\item La combinaison \cmd{CTRL+R} entre en mode recherche dans l'historique. \cmd{CTRL+R} recherche à nouveau.
\end{itemize}
\begin{block}{Astuce}
La commande \cmd{!!} relance la dernière commande. On peut l'utiliser avec \cmd{sudo} pour relancer une commande
en superutilisateur:
\begin{center}
\cmd{sudo !!}
\end{center}
\end{block}
\end{frame}
\begin{frame}[fragile]{Rechercher dans l'historique}
\end{frame}
Loading