La commande "find" permet de chercher des fichiers ou des répertoires dans l'arborescence du disque dur.
C'est une commande très puissante qui parcourt l'arborescence de façon récursive en évaluant l'expression fournie avec le nom des fichiers ou des répertoires.
On peut utiliser des méta-caractères pour remplacer un ou plusieurs caractères lorsque l'on ne connaît pas l'orthographe exacte ou le nom complet du fichier recherché.

?  : remplace n'importe quel caractère (1 caractère)
*  : remplace une suite de caractères (de 0 à n caractères)

Ce petit script va permettre d'utiliser cette commande avec une interface graphique simple (zenity), cela facilite grandement le travail et tolère de délaisser un peu la syntaxe de la commande ainsi que de négliger l'utilisation d'un terminal.

#!/bin/bash

# ---------------------------------------------
# fonction chemin du répertoire
# ---------------------------------------------
R_repert() {
repert=$(zenity --file-selection --directory)    
}

# ---------------------------------------------
# fonction saisie du masque
# ---------------------------------------------
R_masque() {
masque=$(zenity --entry --title "Saisie" --text "Saisie de l'expression de recherche \n les méta-caractères * ? sont fonctionnels \n")
}

# ---------------------------------------------
# fonction recherche tout
# ---------------------------------------------
R_tout() {
find $repert -name "$masque" >~/script/resultat.txt
zenity --text-info --width=700 --height=400 --title "Résultat" --filename "$HOME/script/resultat.txt"
}

# ---------------------------------------------
# fonction recherche fichiers
# ---------------------------------------------
R_fichiers() {
find $repert -name "$masque" -type f >~/script/resultat.txt
zenity --text-info --width=700 --height=400 --title "Résultat" --filename "$HOME/script/resultat.txt"
}

# ---------------------------------------------
# fonction recherche répertoires
# ---------------------------------------------
R_directory() {
find $repert -name "$masque" -type d >~/script/resultat.txt
zenity --text-info --width=700 --height=400 --title "Résultat" --filename "$HOME/script/resultat.txt"
}


# -------------------------------
# boucle principale
# -------------------------------

while true ;
do
code=$(zenity --list --column=code --column=designation --title="Recherche de fichiers" \
    --width=500 --height=350 --hide-header --hide-column=1 \
    --text="Sélectionner une option et valider \n les méta-caractères \n * remplace une série de caractères \n ? remplace un caractère \n \n" \
    1 "Répertoire de recherche récursive       :  $repert " \
    2 "Expression de recherche                      :  $masque" \
    3 "Recherche fichiers+répertoires" \
    4 "Recherche uniquement les fichiers" \
    5 "Recherche uniquement les répertoires" \
    6 "Quitter" )
    
case $code in
    1) R_repert ;;
    2) R_masque ;;
    3) R_tout ;;
    4) R_fichiers ;;
    5) R_directory ;;
    6) break ;;
    
esac

done

Avec Linux comme sous Unix en général, tout est fichier. Les périphériques sont montés en tant que fichiers, les disques durs n'échappent pas à cette règle, on les retrouve donc dans le répertoire /dev.
Lors de l'insertion de la clef (ou d'un disque) dans le port Usb, on peut en vérifier la présence dans un terminal avec la commande   ls /dev/sd*

Voici donc un petit script avec une interface graphique générée par zenity qui permet de monter facilement un disque, une clef ou une image iso.

Il permet aussi de démonter tout disque monté par cette méthode.

#!/bin/bash

# ---------------------------------------------
# fonction select port usb
# ---------------------------------------------
port_usb() {
pusb=$(zenity --list --column=designation --title="choix du port usb" \
    --width=300 --height=250 --hide-header \
    --text="Sélectionner une option et valider \n \n \n" \
    "sda1" \
    "sdb1" \
    "sdc1" )
}

# ---------------------------------------------
# fonction select_iso
# ---------------------------------------------
select_iso() {
f_iso=$(zenity --file-selection )    
}

# ---------------------------------------------
# fonction point de montage
# ---------------------------------------------
p_montage() {
p_mont=$(zenity --file-selection --directory --filename=/media/)    
}


# ---------------------------------------------
# fonction monte_clef sur port usb
# ---------------------------------------------
monte_clef() {
gksu "mount $pusb $p_mont"
}

# ---------------------------------------------
# fonction monte_iso
# ---------------------------------------------
monte_iso() {    
gksudo "mount -o loop -t iso9660 $f_iso $p_mont"
}

# ---------------------------------------------
# fonction demonte_clef sur port usb
# ---------------------------------------------
demonte_clef() {
repert=$(zenity --file-selection --directory --filename=/media/)
gksu umount $repert
}


# -------------------------------
# boucle principale
# -------------------------------

while true ;
do
code=$(zenity --list --column=code --column=designation --title="Monter/Démonter disques" \
    --width=500 --height=350 --hide-header --hide-column=1 \
    --text="Sélectionner une option et valider \n \n \n" \
    1 "Sélection du port usb pour clef   :  $pusb" \
    2 "Sélection de l'image Iso              :  $f_iso" \
    3 "Point de montage du disque       :  $p_mont" \
    4 "Monter la clef usb" \
    5 "Monter l'image Iso" \
    6 "Démonte le disque" \
    7 "Quitter" )
    
case $code in
    1) port_usb ;;
    2) select_iso ;;
    3) p_montage ;;
    4) monte_clef ;;
    5) monte_iso ;;
    6) demonte_clef ;;
    7) break ;;
    
esac

done

Le gestionnaire de fichiers d’un ordinateur permet de manipuler et de trier facilement les fichiers du disque dur.
Certains baladeurs mp3 permettent de «tagger» les fichiers afin de les trier, le mien garde l’ordre naturel d’enregistrement.

L’ordre des fichiers peut-être très important dans certains cas, une série de fichiers classés par chapitres composant un livre audio doit impérativement respecter l’organisation établie initialement.
Avec un ordinateur on peut facilement renommer les fichiers avec un compteur post ou pré fixé qui permet un tri par ordre alphabétique sur le nom, mais cet ordre ne sera pas forcément suivi lors de la recopie sur le baladeur et l’on risque de retrouver l’arrangement des fichiers totalement bouleversé.
Si la liste est modeste, on peut recopier les fichiers un à un, mais cela peut devenir très pénible si le nombre de fichiers devient considérable, la copie manuelle est abandonnée par obligation.

Sous Linux, un petit script bash va permettre de faciliter considérablement le travail de recopie avec l’agencement personnel établi.


La première étape consiste à créer un fichier texte avec l’ensemble des noms de fichiers déjà trié.

find répertoire >liste.txt

On peut aisément modifier cette liste avec un éditeur si nécessaire (une ligne par nom de fichier)
Quand la liste correspond à ce qu’on veut obtenir, on peut ensuite procéder à la copie sur le lecteur mp3

cp liste lecteur_destination

exemple :

cp $(cat liste.txt) /media/disk_mp3/livres

Le petit script suivant est assez intraitable quand aux espaces dans les noms des fichiers, mais n’importe quel outil de renommage en masse permet d’éviter d’en insérer et surtout de les soustraire ou de les transformer en signe souligné _ (sous le chiffre 8 avec la plupart des claviers)

La première option permet de créer un fichier texte avec le chemin complet des fichiers à recopier, cette liste est normalement triée mais si dans l’éventualité où cela ne correspond pas, la deuxième option permet un tri alphabétique sur l’ensemble des lignes du fichier.
La troisième option accède à un éditeur de texte, on peut ainsi personnaliser la liste complète ou en vérifier l’organisation.
La quatrième option va créer un nouveau répertoire sur le baladeur mp3 et la cinquième exécute réellement la recopie dans le répertoire nouvellement créé.

Voici le script

 #!/bin/bash

# --------------------------------------
# fonction création du fichier liste.txt
# --------------------------------------
creliste() {
find /home/mm/script/agencemnt/* > /home/mm/script/liste.txt
}

# --------------------------------------------------------
# fonction tri du fichier liste.txt
# --------------------------------------------------------
triliste() {
sort /home/mm/script/liste.txt > /home/mm/script/listetri.txt
rm /home/mm/script/liste.txt
mv -f /home/mm/script/listetri.txt /home/mm/script/liste.txt
}

# --------------------------------------------------------
# fonction éditer le fichier liste.txt
# --------------------------------------------------------
editliste() {
gedit /home/mm/script/liste.txt
}

# --------------------------------------------------------
# fonction création d'un nouveau répertoire sur la clé mp3
# --------------------------------------------------------
crepert() {
clear
echo
echo
echo --------------------------------------------------
echo Il faut que le baladeur mp3 soit installé
echo --------------------------------------------------
echo
echo "Veuillez saisir le nom du nouveau répertoire"
echo
read nouvrepert
mkdir "/media/disk_mp3/livres/$nouvrepert"
}

# --------------------------------------------------------
# fonction copie des fichiers sur la clé mp3
# --------------------------------------------------------
copyliste() {
clear
echo "-----------------------------------------------------------------"
echo "Patienter jusqu'à réapparition du menu principal"
echo "-----------------------------------------------------------------"
cp $(cat /home/mm/script/liste.txt) "/media/disk_mp3/livres/$nouvrepert"
}

# -----------------
# Boucle principale
# -----------------

while true ;
do
clear
echo
echo "------------------------------------------------------------------------------"
echo "1-Création d'un fichier liste.txt avec le contenu du répertoire /agencemnt/"
echo "2-Un tri alphabétique peut-être effectué directement sur le fichier"
echo "3-On peut également éditer le fichier manuellement"
echo "5-La copie s'effectuera vers /media/disk_mp3 vers nouveau répert s'il est créé"
echo
echo "  Les espaces ne sont pas tolérés dans les noms des fichiers"
echo "------------------------------------------------------------------------------"
echo
echo
echo "***********************************"
echo "*            M E N U              *"
echo "***********************************"
echo "1 - Création du fichier 'liste.txt'"
echo "2 - Tri du fichier 'liste.txt'"
echo "3 - Editer le fichier 'liste.txt'"
echo "4 - Création d'un nouveau répertoire sur la clé mp3"
echo "5 - Copie les fichiers vers la clé mp3"
echo "6 - Quitter"
read choix
case $choix in
1) creliste;;
2) triliste;;
3) editliste;;
4) crepert;;
5) copyliste;;
6) break
esac
done

Afin de mieux connaître son système d’exploitation, la création d’un journal des installations permet de suivre l’occupation de son disque dur, comprendre l’origine des fichiers qui s’approprient la place sur le disque.

On peut de cette façon effectuer des désinstallations manuelles en effaçant exclusivement les fichiers dont on connaît la source et la destination.

Le logiciel d’installation/désinstallation (Software Manager) fait cela très bien, mais ne laisse pas d’alternative entre une installation ou une désinstallation complète, il laisse aussi quelquefois des traces qu’on détecte difficilement étant donné la densité des fichiers dans ces répertoires.

La création de ce journal permet aussi de rester le décisionnaire sur le suivi de son système, on accède aussi de cette manière à l’orthographe du nom de l’exécutable du logiciel installé, du chemin complet des répertoires contenant les fichiers de configuration et d’initialisation, des fichiers d’icônes etc...

On reste de ce fait l’administrateur de son système.

C’est un script bash très simple avec une interface graphique réalisée avec zenity.

- l’examen initial :
      Explore le disque dur et créé une liste de l’ensemble des fichiers

Il faut ensuite procéder à l’installation du programme et modifier ainsi le système.

- l’examen de contrôle :
      Explore à nouveau le disque dur et créé une nouvelle liste.

- ajout dans le journal :
     Procède à une comparaison des deux listes et extrait les fichiers ajoutés avec leur chemin, la liste des ajouts sera affichée à l’écran et ajoutée au fichier journal.

Dans le script les fichiers sont lus/écrits dans le répertoire dont le chemin absolu est ~/.zen/, c’est le répertoire de travail des différentes listes et du journal, il est possible de le personnaliser en modifiant tous les chemins ~/.zen/ avec le nom d’un autre répertoire.

Le journal ne contient pas les données inscrites dans le dossier personnel, il s’agit le plus souvent de fichiers de configurations et bien sûr des fichiers d’exploitation résultant du travail accompli avec le logiciel.

 Extrait du résulat de l'enregistrement de l'installation du logiciel "scribus" dans le journal

La même version avec interface texte dans un terminal

Suppression totale d’une installation en mode manuel

Pour supprimer une série de fichiers facilement avec un ordre bash, il faut créer un nouveau fichier texte et y transcrire la liste des fichiers à supprimer d’un simple copier/coller du journal vers le fichier.

Dans une console envoyer l’ordre :

sudo rm $(cat fichier.txt)

La suppression est immédiate après la saisie du mot de passe administrateur, sans aucune confirmation.

Simple et efficace.



 

# ---------------------------------------------
# fonction sélection du répertoire des fichiers
# ---------------------------------------------
sel_repert() {
repert=$(zenity --file-selection --directory)
cd $repert
}

 # --------------------------------------------------

# fonction saisie du filtre de sélection de fichiers
# --------------------------------------------------
sel_fich() {
filtre=$(zenity --entry --title "Sélection de fichiers" 
 --text "sélection des fichiers à renommer \n
* remplace une chaîne de n importe quelle longueur \n
ex : *.jpg = tous les fichiers avec extension jpg \n
 * = tous les fichiers \n
 *.* = tous les fichiers avec une extension \n\n\n" )
}

# -------------------------------
# fonction du nom de remplacement
# -------------------------------
remplace() {
nouvnom=$(zenity --entry --title "Nouveau nom" 
 --text "Saisie du nouveau nom avec extension \n
ex : naissance bb.jpg \n \n" )
}

# ------------------------------
# Saisie de l'indice du compteur
# ------------------------------
indice() {
compt=$(zenity --entry --title "Début du compteur" 
 --text "Saisie de l'indice de début de compteur \n
si l'on veut un compteur avec 4 chiffres, commencer à 1000 \n
ex : 2500 \n \n" )
}

# ----------------------------------------
# fonction Visualisation des modifications
# ----------------------------------------
visu() {
cat >$HOME/.zen/renfich
cpt=$compt
for fichier in $filtre
do
 echo "$fichier" >>$HOME/.zen/renfich
 echo " = " >>$HOME/.zen/renfich
 echo "$cpt $nouvnom" >>$HOME/.zen/renfich
 let "cpt+=1"
done
zenity --list --column="Ancien nom" --column="=" --column="Nouveau nom" --title="Visualisation" 
 --height=300 --width=700 --text "" <$HOME/.zen/renfich
}

# -------------------------------
# fonction Renommage des fichiers
# -------------------------------
modif() {
cpt=$compt
for fichier in $filtre
do
mv "$fichier" "$cpt $nouvnom"
let "cpt+=1"
done
}

# -----------------
# Boucle principale
# -----------------
while true ;
do
code=$(zenity --list --column=code --column=designation --title="M E N U" 
 --width=700 --height=350 --hide-header --hide-column=1 
 --text="Renomme une série de fichiers selon le format suivant : XXXX NOM.EXT \n \n \n" 
 1 "Répertoires des fichiers à renommer : $repert" 
 2 "Sélection des fichiers : $filtre" 
 3 "Saisie du nom de remplacement : $nouvnom" 
 4 "Saisie de l'indice de début de compteur : $compt" 
 5 "Visualisation des modifications" 
 6 "Renommer les fichiers" 
 7 "Quitter" )

case $code in
 1) sel_repert ;;
 2) sel_fich ;;
 3) remplace ;;
 4) indice ;;
 5) visu ;;
 6) modif ;; 
 7) break ;;
esac

done

L'option "renommer les fichiers" du menu principal va valider vraiment les modifications des noms des fichiers.