L'astuce du jour : trouver les X fichiers les plus volumineux dans un PATH donné ?

find / -xdev -type f -size +100M -exec du -sh {} ';' | sort -rh | head -n50

Cette commande affiche sur la sortie standard tous les fichiers :

• se situant dans le répertoire / (récursivement);
• pesant au minimum 100 MB;
• dans la limite de 50 fichiers affichés.

La partition / de mon PC commençait sérieusement à manquer d'espace aujourd'hui (moins de 1.5 Go disponibles). J'ai donc cherché partout la raison de ce remplissage. D'autant que j'ai partitionné mes disques de telle façon que le / n'ai aucune raison de se remplir sans une action directe de ma part (mises à jours, ajout volontaire de fichiers, etc).

Et puis en utilisant un peu de magie (et un peu de find), j'ai trouvé l'immonde coupable : .xsession-errors !

Ce petit impertinent est un fichier de log qui recense les erreurs graphiques de tout un tas d'applications, et en particulier des gestionnaire de fenêtres (Nemo dans mon cas). Situé à la racine de mon home, il a réussi à gonfler jusqu'à prendre 4 Go !

Comme il s'agit d'un fichier de log, je me demande bien ce qu'il peut faire ici au lieu d'être, par exemple, dans ... /var/log ! Ça use mon SSD pour rien en plus !
Bref.

Pour désactiver l'écriture des logs dans ce fichier :

• ouvrir le fichier /etc/X11/Xsession;
• chercher la variable nommée ERRFILE=$HOME/.xsession-errors;
• commenter la ligne et ajouter en dessous la ligne suivante : ERRFILE=/dev/null

Au lieu d'écrire dans le fichier, les logs iront maintenant se perdre dans le vide sidéral.

Pour tester si une page existe sans la télécharger :

#!/bin/bash

# Renvoie "true" si la page passée en argument existe.
# @param $1 : l'URL de la page dont on veut tester l'existence.
# @return true si la page existe, false sinon.
is_URL_real()
{
    local page_exists
    page_exists="false"

    if [[ `wget --server-response --spider "$1"  2>&1 | grep 'HTTP/1.1 200 OK'` ]]; then
        page_exists="true"
    fi

    echo "$page_exists"
}

is_URL_real "$1"

Ce qui donne à l'exécution :

./test_URL.sh "https://www.qwant.com"
true

A propos des variables de type local en Bash.

Tout d'abord, la sécurité.
Afin d'écrire plus rapidement, on se retrouve souvent à déclarer et initialiser la variable en même temps :

local var="plouf plouf"

Sauf qu'en faisant ça, l'ordre d'exécution est le suivant :

• attribution de la valeur plouf plouf à la variable var;
• restriction de la portée de la variable var au niveau local.

Ce qui signifie que la variable reste accessible pendant un instant au niveau global. Il faut donc mieux faire la déclaration et l'instanciation en deux temps :

local var
var="plouf plouf"

Ce qui m'amène au deuxième point. Une fois qu'une variable a été déclarée local, il n'est pas besoin de remettre le mot-clef local à chaque instanciation. Ainsi, si je considère le script suivant :

#/usr/bin/env bash

ma_fonction()
{
    local var = "ALEX"
    echo "$var"

    var="TOM"
    echo "$var"
}

ma_fonction

echo "<$var>"

La sortie sera :

ALEX
TOM
<>

Un moyen de créer des répertoires plus rapidement.

Je veux créer des répertoires ayant un nom basé sur le même modèle. Par exemple REPERTOIRE.ABC.08.

Pour créer tous les répertoires de 08 à 14, je peux utiliser une boucle for dans laquelle un compteur s'incrémente dans une string, laquelle est passée à mkdir.

Ou alors je peux utiliser une capacité de la commande mkdir :

mkdir REPERTOIRE.ABC.{08..14}
# Ce qui me donne :
ls -a
REPERTOIRE.ABC.08
REPERTOIRE.ABC.09
REPERTOIRE.ABC.10
REPERTOIRE.ABC.11
REPERTOIRE.ABC.12
REPERTOIRE.ABC.13
REPERTOIRE.ABC.14

Je peux utiliser une suite de lettres :

mkdir REPERTOIRE.{a..f}
# Ce qui me donne :
ls -a
REPERTOIRE.a
REPERTOIRE.b
REPERTOIRE.c
REPERTOIRE.d
REPERTOIRE.e
REPERTOIRE.f

Je peux utiliser plusieurs "suites" dans le même motif. Attention toutefois, car toutes les combinaisons seront créees :

mkdir REPERTOIRE.{a..c}_{0..3}
# Ce qui me donne :
ls -a
REPERTOIRE.a_0
REPERTOIRE.a_1
REPERTOIRE.a_2
REPERTOIRE.a_3
REPERTOIRE.b_0
...
REPERTOIRE.c_3

Le bonus de fin : je peux parcourir une suite de nombres avec un pas supérieur à 1 :

# Pour un pas de 2
mkdir REPERTOIRE.{1..7..2}
# Ce qui me donne :
ls -a
REPERTOIRE.1
REPERTOIRE.3
REPERTOIRE.5
REPERTOIRE.7

Edit : si au lieu d'une suite de caractères je veut utiliser une liste de valeurs prédéfinies je peux utiliser la virgule :

mkdir dossier_{toto,1,007,AZ}
# Ce qui me donne
ls -a
dossier_toto
dossier_1
dossier_007
dossier_AZ

Pour une arborescence, j'utilise aussi l'option -p :

mkdir -p parent{1..4}/enfant{bill,bob,ben}
# Ce qui me donne
tree
.
├── parent1
│   ├── enfantben
│   ├── enfantbill
│   └── enfantbob
├── parent2
│   ├── enfantben
│   ├── enfantbill
│   └── enfantbob
├── parent3
│   ├── enfantben
│   ├── enfantbill
│   └── enfantbob
└── parent4
    ├── enfantben
    ├── enfantbill
    └── enfantbob

Pour mémoire.
Comment extraire la n-ème ligne d'une fichier en bash?

Soit le fichier suivant :

Ligne 01
Ligne 02
Ligne 03
Ligne 04
Ligne 05
Ligne 06
Ligne 07

Avec l'outil sed :

# J'extrais la 4eme ligne du fichier
cat mon_fichier | sed "4q;d"

# Ce qui donne
Ligne 04

# J'extrais la 67eme ligne (avec une variable)
var="67"
cat mon_fichier | sed "${var}q;d"

Aujourd'hui je suis tombé sur ça :

for i in $(seq 0 $var)
do
   echo "bla bla bla"
done

Il s'agit d'une des multiples façons d'utiliser la boucle for en bash. Sauf que :

• la boucle dépend de la commande seq, qui prend une quantité de RAM importante pour de grandes séquences;
• il s'agit d'une façon désuète d'utiliser la boucle for. Elle ne devrait être utilisée que pour des raisons de retro-compatibilité avec de vieux shells.

Depuis la version 4 de bash qui, je le rappelle, est sortie en février 2009, il existe une nouvelle façon d'utiliser la boucle for :

# Pour i de 1 à $var par pas de 1
for (( i=1; i<=$var; i++ ))
do
   echo "bla bla bla"
done

Ou encore :

# Pour i de 3 à 47 par pas de 4
for i in {3..47..4}
do
   echo "bla bla bla"
done

Il serait temps de s'y mettre !

Afin d'éviter de créer des scripts troués, une bonne pratique est d'utiliser le double-tiret -- pour marquer la fin des options d'une commande bash.

En effet, supposons que je veuille lister les fichiers d'un répertoires. Rien n'empêche qu'un répertoire s'appelle -o et active donc l'option associée. Pour signifier à la commande ls d'ignorer ce qui suit mes options je procède ainsi :

# Mon répertoire s'appelle "-o -a"
var="-o -a"
# J'ajoute un double-tiret pour signifier la fin des options
ls -l -- "$var"
# Une fois la variable évaluée, la commande ressemblera à ceci
ls -l -- -o -a
# Et seule l'option -l sera prise en compte

Cette convention est reprise par toutes les commandes built-in de bash (+ d'autres shells comme csh et sh) sauf une poignée (true, false, echo et eval).

J'avais fais quelques tests il y a quelques mois, pour voir ce qu'on pouvait faire en "hackant" les options des commandes. Pour ls c'est ennuyeux. Mais il suffit d'imaginer les conséquences avec rm par exemple ...

Note à moi-même : il faudra que j'essaie getopt pour créer un parseur d'options en bash.

La même chose mais avec l'outil sed cette fois.

Je veux donc afficher ce qui se trouve entre deux motifs, mais en utilisant des variables à la place des motifs. J'utilise le fichier suivant :

Ce fichier est un fichier particulier
car il contient un passage sensible situé
entre MOTIF_01 et
une balise
de fin
appelée MOTIF_02. Il s'agit d'extraire
ce qui se situe entre les deux.

Pour cela j'utilise sed de la façon suivante :

# Le cas classique avec MOTIF_01 et MOTIF_02
cat mon_fichier | sed -n "/MOTIF_01/,/MOTIF_02/p"
# Ce qui me donne
entre MOTIF_01 et
une balise
de fin
appelée MOTIF_02. Il s'agit d'extraire

En fait, cela me donne ce qui se trouve entre les lignes comprenant les motifs, en plus des lignes comprenant les motifs. Après ça, un substitution avec sed "s///" finit le travail.

# En utilisant des variables (il suffit de les ajouter aux motifs)
cat mon_fichier | sed -n "/MOTIF_01$VAR_01/,/$VAR_02/p"

Cette fois c'est une capacité de l'outil awk qui m'intéresse.

Comment afficher ce qui se trouve entre deux motifs ? Le point fort est que cette méthode fonctionne même si les motifs ne sont pas sur la même ligne :

# J'affiche ce qui se trouve entre le motifs MOTIF_01 et MOTIF_02
cat mon_fichier | awk "/MOTIF_01/,/MOTIF_02/"

Dans ce cas, les motifs sont affichés avec ce qui les sépare. Le résultat peut ressembler à quelque chose comme ça :

bla bla bla MOTIF_01 toc
//Plein de trucs se trouvant entre les motifs
paf pouf MOTIF_02 plouf plouf

Une option bien utile de l'outil grep.

Je veux chercher un motif dans un fichier texte. Mais je veux également afficher un certain nombre de lignes avant/après ce motif. J'utilise le fichier suivant :

Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Nulla et vehicula lectus.
Integer sit amet augue est.
Vivamus vestibulum pretium ex.
Praesent in nunc nec turpis aliquam porttitor.
Etiam leo quam, bibendum nec velit eget, aliquam malesuada justo.
Aliquam sit amet dapibus enim.
Proin eget velit vehicula, vulputate augue eget, maximus diam.
Aenean pellentesque, nisi id viverra tempor, neque dui lacinia nisi, et ultricies nunc turpis at mauris.

Pour cela, j'utilise les options -A et -B de grep ainsi :

# En plus du motif recherché, j'affiche 2 lignes au-dessus et 3 lignes en-dessous
cat mon_fichier | grep -E " turpis aliquam " -A3 -B2

Ce qui me donne

Integer sit amet augue est.
Vivamus vestibulum pretium ex.
Praesent in nunc nec turpis aliquam porttitor.
Etiam leo quam, bibendum nec velit eget, aliquam malesuada justo.
Aliquam sit amet dapibus enim.
Proin eget velit vehicula, vulputate augue eget, maximus diam.

Il faut lire ces options comme :

• -A pour After;
• -B pour Before.

Le nombre qui les suit indique le nombre de lignes à garder avant/après.

Si le nombre de lignes à garder avant/après est le même, alors je peux utiliser l'option -C :

# En plus du motif recherché, j'affiche 1 ligne au-dessus et en-dessous
cat mon_fichier | grep -E "amet dapibus" -C1

Ce qui me donne

Etiam leo quam, bibendum nec velit eget, aliquam malesuada justo.
Aliquam sit amet dapibus enim.
Proin eget velit vehicula, vulputate augue eget, maximus diam.

Tant qu'à parler d'astuces : j'utilise ce comportement depuis un certain temps maintenant. Il s'avère que dans Nemo (le gestionnaire de fichiers de Cinnamon), on peut annuler la suppression ou le déplacement d'un fichier. Pour cela, il suffit de faire un CTRL + Z dans la fenêtre du répertoire où à été réalisée l'action.

#ShortcutLover

Un disque dur mécanique se met en stand-by après une certaine durée pour économiser de l'énergie. Résultat? Quand je souhaite y accéder, le moteur qui fait tourner les disques doit se remettre en mouvement, et cela prend toujours un certain temps (plusieurs secondes).

Pour régler le temps au-delà duquel le disque se met en "veille" je peux utiliser l'outil hdparm (Linux) :

# J'affiche les informations relatives au disque sda
sudo hdparm -I /dev/sda

Puis je regarde la ligne Advanced power management level.

Quelques infos sur ce nombre tirées de cette page (traduction du manpage) :

-S
Paramétrer le temps mort du stand-by de périphérique.

Usage :

0 : désactive ; le périphérique ne rentrera pas en mode stand-by.
De 1 à 240 : spécifie des multiples de 5 secondes, avec des temps morts de 5 secondes à 20 minutes.
De 241 à 251 : spécifie de 1 à 11 unités de temps de 30 minutes chacune, avec des temps morts de 30 minutes à 5 h 30.
252 : spécifie un temps mort de 21 minutes.
253 : est une période de temps mort définie par le fabriquant, entre 8 à 12 heures.
254 : réservée !
255 : est interprétée comme 21 minutes plus 15 secondes.

Pour changer le temps de stand-by, il suffit d'utiliser correctement ces valeurs :

# Pour désactiver le stand-by
sudo hdparm -S 0 /dev/sda

# Pour le fixer à 2 minutes (5 secondes x 24)
sudo hdparm -S 24 /dev/sda

# Pour le fixer à 01h30 (30 minutes * 3)
sudo hdparm -S 243 /dev/sda

Attention: ne pas confondre avec l'option -s (minuscule) qui n'a pas du tout le même effet !

Sinon, tu pouvais :

• lancer gparted

Le disque n'apparaissait pas dans GParted. Tu penses bien que j'ai essayé avant de tenter la solution CLI.

Je garde ça sous le coude.

Différentes façon de comparer le contenu de deux répertoires.

Pour connaître le path d'un script à l'intérieur de ce même script, il faut utiliser :

PATH=${BASH_SOURCE[0]}

Au lieu de :

PATH=$0

En effet, la première méthode retourne le path du script courant même s'il est sourcé (ie lancé comme ceci : ./script.sh).

Aujourd'hui j'ai voulu essayer mon nouvel adaptateur SATA/USB pour lire un disque dur 3,5 pouces. Il dispose d'un cable d'alimentation à brancher sur l'adaptateur. Et ça n'a pas marché :-(
J'ai donc vérifié que l'adaptateur fonctionnait avec un disque 2,5 pouces (sans alimentation donc). Ok.

J'ai rebranché le disque 3,5 pouces :

• pas de disque monté;
• rien dans /dev ni dans /sys/bloc;
• la seule apparition du disque dans le système se situait dans dmesg. Je n'ai malheureusement pas noté la trace à ce moment là. Je me souviens simplement que les logs disaient quelque chose du genre DO_NOT_CONNECTED et error = -32.

Et puis je me suis rappelé que le disque était neuf. Donc jamais formaté.

Problème : comment formater un disque invisible?

En effet il faut indiquer à fdisk quel disque formater (ex: /dev/sdc).

J'ai résolu le problème en redémarrant le PC puis en passant en mode console dès l'écran de connexion avec CTRL + ALT + F1 :

• je m'identifie avec login/password;
• je liste les disques au cas où :

# Miracle ! je vois un disque supplémentaire (/dev/sdc en l'occurence)
ls -la /dev | grep sd

• je lance l'outil cfdisk :

sudo cfdisk /dev/sdc

• j'arrive sur l'interface de cfdisk (c'est presque gagné);
• je choisis alors le type de partition dos;
• puis je vérifie que les infos sont bonnes (colonne Size);
• je crée la table de partitions. Je choisis la taille de la (des) partition(s), ainsi que le type primaire ou étendu;
• je crée la (les) partition(s) en écrivant yes;
• le message suivant s'affiche : "The partition table has been altered";
• finalement je quitte cfdisk;
• je vérifie qu'une nouvelle partition est apparue dans /dev (sdc chez moi);
• je peux aussi vérifier en tapant :

sudo fdisk -l

Je constate alors que ma nouvelle partition apparaît avec toutes ses infos.

Je peux alors revenir en mode graphique avec CTRL+ ALT + F7 et m'authentifier.

Pour formater ma partition en ext4, je peux utiliser GParted ou bien grâce au terminal :

sudo mkfs.ext4 /dev/sdc1

Mon disque apparaît alors dans le gestionnaire de fichiers.

Pour info :

• temps de création de la table de partitions : quelques secondes;
• temps de formatage de la partition : quelques secondes.

Edit : il est possible que le disque ne soit pas accessible en écriture dans Nemo (ou quel que soit le gestionnaire de fichiers). Il faut alors se servir du terminal :

# Pour changer le propriétaire du répertoire (root par défaut) :
sudo chown mon_utilisateur:mon_utilisateur /media/REPERTOIRE_DE_MONTAGE

# Pour changer les droits sur le répertoire :
sudo chmod u+rwx /media/REPERTOIRE_DE_MONTAGE

mediainfo, l'outil en CLI à mettre dans les utilitaires indispensables !

Pour insérer un caractère Unicode dans un texte sous GNU/Linux :

• taper la combinaison de touches suivante : CTRL + SHIFT + u;
• une lettre u soulignée apparaît;
• il reste alors à taper le code du caractère désiré. Si le caractère n'apparaît pas tout seul en remplacement de la chaîne uXYZ, il faut alors appuyer sur la touche Entrée.

Par exemple :

• Ctrl + Shift + u suivi du code 153 (ou 0153) puis Entrée donne le caractère œ;
• Ctrl + Shift + u suivi du code D8 (ou 00D8) donne le caractère Ø (pas besoin d'appuyer sur Entrée);
• Ctrl + Shift + u suivi du code 2030 donne le caractère ‰ (pas besoin d'appuyer sur Entrée).

On peut évidemment utiliser les chiffres du pavé numérique ou du clavier.

Sous Windows c'est un autre système que je n'ai pas testé.