Catégorie : Bash

Publié le

screen

screen n’est pas facile à décrire. En gros, il permet de créer une couche entre le système d’exploitation (le kernel) et une ou plusieurs applications. Il permet d’activer plusieurs applications dans une seule fenêtre d’affichage. Il est souvent utilisé avec les applications textuelles pour les détacher/attacher de leur écran.

En général, screen n’est pas installé par défaut mais il s’installe facilement avec votre gestionnaire de paquets.

Démarrage de screen

Le démarrage est simple:

screen prog

si prog n’est pas spécifié, un shell (bash) sera démarré

Détacher une tâche

Si prog s’exécute et est visible dans la fenêtre screen, on peut les séparer (détacher). La fenêtre gérée par screen se fermera automatiquement. Il y a deux façons:

  • dans la fenêtre de l’application (gérée par screen), presser ^a suivi de d. Le préfixe ^a est requis pour éviter que le d soit traité par l’application.
  • dans une fenêtre bash: screen -d

Reprendre une tâche

Si prog est une application détachée de sa fenêtre screen, on peut la ré-associer avec  l’une des 2 façons suivantes:

  • dans une fenêtre bash: screen -r nom
  • dans une fenêtre screen: ^a r nom

Dans les 2 cas, nom est le nom donné par screen à chacune des applications qu’il gère. Il n’est pas nécessaire de spécifier le nom au complet. Il suffit de spécifier les premiers caractères du nom. Si screen ne gère qu’une seule application, le nom est facultatif. Pour connaitre le nom des applications gérées, on utilise screen -list (dans une fenêtre bash).

Exemple (2 sessions vi dans la même fenêtre):

screen vi abc^ad         #dans la fenêtre viscreen vi xyz^adscreen -listThere are screens on:
     15780.pts-6.local4 (Detached)
     13865.pts-6.local4 (Detached)
2 Sockets in /home/u/tmp.
screen -r 13   # récupérer la session d'édition de abc

Conclusion

screen était populaire à l’époque où il n’y avait pas de gestionnaire de fenêtres. Aujourd’hui, on l’utilise sur des équipements à ressources limitées ou pour éviter d’interrompre une application s’il y a déconnexion de son terminal.

screen peut gérer plusieurs fenêtres. Une application peut être ouverte dans une fenêtre puis réactivée dans une autre. Pour plus de détails: man screen

 

Publié le

Survivre à une déconnexion

Lorsqu’on démarre une tâche sur un ordinateur distant, il faut s’assurer que la tâche est terminée avant de rompre la connexion. En effet, le comportement de Linux dans le cas où une communication est rompue est d’envoyer un signal SIGHUP aux programmes qui dépendent de cette connexion. Si rien n’a été fait pour le contrer, le comportement par défaut est d’arrêter brusquement la tâche.

Déléguer une tâche longue à une autre machine est courant dans le monde Unix/Linux. Mais il faut prendre certaines précautions pour éviter que notre tâche qui s’exécute sur le serveur ne soit avortée par le fait qu’on déconnecte notre portable pour l’amener à la maison.

Vérifions comment notre appli réagit à un signal SIGHUP:

kill -SIGHUP $(pidof appli)

ou

pkill -SIGHUP appli

Si l’application avorte et que ce comportement ne nous convient pas, on pourra utiliser l’une des approches suivantes:

Ajouter le traitement du SIGHUP à notre application

S’il s’agit d’un programme qu’on a écrit ou d’un logiciel libre dont on a le code source, il est facile d’ajouter du code pour traiter le signal SIGHUP.

Demander à bash d’ignorer le signal

Si la solution précédente n’est pas possible, on peut demander à bash d’ignorer le signal SIGHUP:

trap '' SIGHUP
./appli args
trap SIGHUP    # reprendre le comportement par défaut

Exemple d’un script qui ignore les SIGHUP (pour la durée du script):

trap '' SIGHUP
./appli args

On peut aussi utiliser le programme nohup qui déconnecte l’appli de ses canaux standards et envoie toute sortie vers le fichier nohup.out

nohup appli args

screen

screen a été conçu pour gérer plusieurs applications pour une même connexion. Un effet collatéral est que screen créée un lien virtuel entre une application et ses canaux standards (STDIN, STDOUT, STDERR).  Par conséquent, une déconnexion du lien de communication n’est pas perçue par l’application. La tâche continue à s’exécuter en arrière-plan et lorsqu’on rétablit la connexion, on peut refaire le lien avec l’application.

tmux

tmux est semblable à screen et réalise les mêmes fonctions. Sa principale différence est qu’il est de facture plus moderne. tmux se définit comme ‘multiplexeur de terminaux’. Il reprend les concepts de screen mais ajoute un gestionnaire de fenêtre qui partage la fenêtre en zones rectangulaires.

awesome

 

Publié le

Redirection

Tous les programmes démarrent avec 3 canaux d’entrée-sorties déjà ouverts. Ce sont:

  • 0 (stdin) : entrée normale, généralement le clavier
  • 1 (stdout): sortie normale, généralement l’écran
  • 2 (stderr): sortie des messages d’erreur, généralement l’écran

bash nous permet de rediriger ces canaux vers les entrée-sorties qui correspondent à nos besoins. Trois caractères spéciaux ( <>| ) sont utilisés. Supposons le programme unProg:

unProg <  fichier   # utiliser un fichier au lieu du clavier
unProg >  fichier   # rediriger la sortie vers un fichier (le vider d'abord)
unProg >> fichier   # rediriger la sortie vers un fichier (ajouter au fichier)
unProg | autreProg  # rediriger la sortie vers un autre programme

Un exemple:

cat fichier | wc -l # afficher le nombre de lignes du fichier

Le programme cat affiche le contenu d’un fichier mais, dans ce cas-ci, sa sortie n’ira pas vers l’écran mais plutôt vers le programme wc -l qui compte le nombre de ligne dans le texte entré. Dans ce cas-ci, l’entrée de wc n’est pas le clavier mais, à cause de la redirection, c’est plutôt la sortie du programme précédent.

La forme générale d’une redirection de fichier est n> ou n< où n est le numéro du canal d’entrée-sortie. Donc:

unProg 2> fichier_erreurs

redirige le canal 2 (les messages d’erreurs) vers un fichier. On aura compris que > (sans numéro de canal) est une abréviation de 1>.

Fusion de flux

La formulation n>&m permet de fusionner le canal n avec le canal m

Donc. la commande unProg > fichierX 2>&1    signifie:

  • envoyer la sortie normale vers fichierX
  • fusionner le canal2 (erreurs) et le canal1 (sortie normale)

Notez que l’évaluation se fait de gauche à droite et que, par conséquent, la commande unProg  2>&1  >fichierX ne dirige pas les messages d’erreur vers fichierX

Autres exemples:

prog 1> fich1 2>fich2 # rediriger les canaux 1 et 2
prog 2> /dev/null     # diriger la sortie d'erreur vers la poubelle

Note: il ne faut pas insérer d’espace entre les caractères de n> ou n>&m

Dans le cas d’une redirection vers un programme, on ne peut pas spécifier les canaux; c’est toujours 1 vers 0 (sortie normale vers l’entrée). Si c’est vraiment nécessaire, il y a, bien sur, une façon de diriger 2 (les erreurs) vers l’entrée:

unProg 3>&1   1>&2   2>&3 | autreProg  # on permute 1 et 2

Publié le

Quelques astuces Bash

Même si vous êtes habile pour pianoter sur un clavier, il est possible d’augmenter votre performance en utilisant quelques astuces de bash.

L’auto-complément est évidemment une technique très efficace mais il y a aussi plusieurs astuces d’édition qu’il y a avantage à connaître.

Auto-complément

La touche Tab permet de compléter le mot courant. C’est utile pour les mots longs ou si vous ne vous souvenez pas de l’orthographe exact.

Si le Tab est donné durant le 1er mot, l’expansion du Tab proposera toutes les commandes disponibles qui débutent avec les caractères entrés. S’il n’y en a qu’une, elle s’inscrira dans votre ligne de commande, sinon vous devrez entrer des caractères supplémentaire pour raffiner la sélection.

Si la touche Tab n’est pas dans le 1er mot, alors bash proposera une liste des fichiers du répertoire courant.

L’auto-complément est tellement utile que son concept a été étendu pour le rendre plus intelligent. Mais cette fonctionnalité n’est possible que pour certaines commandes. Pour ces commandes, si le Tab est utilisé ailleurs que dans le 1er mot, alors la recherche sera optimisée en fonction du 1er mot. Par exemple, si vous entrez Tab après man conf, alors bash vous proposera une liste de toutes les pages de manuel des commandes qui débutent par conf.

Nous verrons, dans un autre article, comment on peut ajouter nous-même la fonctionnalité d’auto-complément à une commande quelconque.

Accès à l’historique

Toutes vos lignes de commandes sont mémorisées dans un fichier d’historique. Les touches de flèches verticales vous permettent de vous promener dans l’historique et de récupérer une de ces vieilles commandes. De plus, la combinaison ctrl-r permet de rechercher dans le fichiers d’historique en fonction des caractères que vous entrez.  Un ctrl-r supplémentaire permet d’aller plus loin dans le fichier. Utilisez une touche de flèche horizontale lorsque vous avez la commande désirée ou que vous voulez terminer la recherche. Pour plus de détails.

Mise en commentaire Alt-#

Vous est-il déjà arrivé, en cours d’édition d’une commande, de constater que vous avez un blanc de mémoire? Vous allez alors dans une autre fenêtre (ou un autre onglet) et vous interrogez man. Mais si vous n’avez pas cette autre fenêtre, vous pouvez utiliser l’astuce suivante. Si vous utilisez Alt-# dans votre commande courante, un # sera introduit en début de commande (pour en faire un commentaire) et la commande se terminera sans effet. Après avoir consulté man, la flèche ascendante vous ramène votre commande et il n’y a plus qu’à la compléter et enlever le #.

Rappel du premier mot de la commande précédente

La combinaison Alt-. vous ramène le premier mot de la commande précédente.

Dernier argument !$

Très utile lorsque vous avez à entrer 2 commandes qui se terminent par le même argument. Exemple:

nano chemin/fichier
lp !$

nano est un éditeur de texte et lp est une commande d’impression. L’expansion du !$ récupère le dernier argument de la commande précédente. Vous pouvez obtenir le même résultat en utilisant Esc et . (touche Esc suivie de la touche . )  ou Esc–_. Vous pouvez utiliser cette séquence plusieurs fois pour avoir accès au dernier paramètre d’une plus vieille commande.

nième argument

De la même façon qu’avec !$, vous pouvez utiliser !:n pour obtenir le nième argument

Commandes d’édition de la ligne en cours

  • ctrl-a déplace le curseur vers le début de la ligne
  • ctrl-e déplace le curseur vers la fin de la ligne
  • ctrl-t permute le caractère courant avec le précédent (ou les 2 derniers si le curseur est en fin de ligne). C’est très utile.
  • alt-t intervertit 2 mots. Semblable à ctrl-t
  • alt-d supprime le mot (ou portion de mot) après le curseur
  • ctrl-w efface le mot à la gauche du curseur
  • ctrl-u coupe tous les caractères à la gauche du curseur
  • ctrl-k coupe tous les caractères à la droite du curseur
  • ctrl-y ramène les caractères du presse-papier (coupés par ctrl-u ou ctrl-k, etc)
  • ctrl-l efface le contenu de la fenêtre en conservant la ligne courante
  • alt-u met en majuscules le mot (ou portion de mot) qui suit le curseur
  • alt-l met en minuscules le mot (ou portion de mot) qui suit le curseur
  • alt-c met en majuscule la lettre sous le curseur

Autres combinaisons utiles

  • ctrl-c termine le programme en cours
  • ctrl-z met en pause le programme en cours
  • ctrl-l nettoie la fenètre
  • ctrl-s bloque le défilement de texte
  • ctrl-q débloque le défilement de texte
  • ctrl-d signale une fin de fichier. En ligne de commande, il ferme la fenètre

Le presse-papiers du bureau (ne pas confondre avec celui de bash)

  • ctrl-C copier vers le presse-papiers (notez la majuscule qui nécessite Shft)
  • ctrl-V ramener le presse-papiers (notez la majuscule qui nécessite Shft)